diff --git a/frameworks/native/audioadapter/include/audio_service_adapter.h b/frameworks/native/audioadapter/include/audio_service_adapter.h
index 35b6189dd3495d85ea0d4c930705a1b72017d778..f6fe2bfa764c01b2c82cd6697c0c35c700856a10 100644
--- a/frameworks/native/audioadapter/include/audio_service_adapter.h
+++ b/frameworks/native/audioadapter/include/audio_service_adapter.h
@@ -243,6 +243,9 @@ public:
      */
     virtual int32_t SetSystemVolumeToEffect(AudioStreamType streamType, float volume) NOT_SUPPORT_RET
     virtual ~AudioServiceAdapter();
+
+    virtual int32_t AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) = 0;
+    virtual int32_t RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) = 0;
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/frameworks/native/audioadapter/include/pro_audio_service_adapter_impl.h b/frameworks/native/audioadapter/include/pro_audio_service_adapter_impl.h
index 8fed4960e8db39d16ea3da78b8b2355eda8bc487..6be197b77dc228374e34c8eac3817573489341aa 100644
--- a/frameworks/native/audioadapter/include/pro_audio_service_adapter_impl.h
+++ b/frameworks/native/audioadapter/include/pro_audio_service_adapter_impl.h
@@ -60,6 +60,8 @@ public:
     int32_t UpdateCollaborativeState(bool isCollaborationEnabled) override;
     int32_t SetAbsVolumeStateToEffect(const bool absVolumeState) override;
     int32_t SetSystemVolumeToEffect(AudioStreamType streamType, float volume) override;
+    int32_t AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) override;
+    int32_t RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) override;
     // callback Member functions
     virtual void OnOpenAudioPortCb(int32_t portId) override;
     virtual void OnReloadAudioPortCb(int32_t portId) override;
diff --git a/frameworks/native/audioadapter/include/pulse_audio_service_adapter_impl.h b/frameworks/native/audioadapter/include/pulse_audio_service_adapter_impl.h
index 58c7ec7fc760e8d8e4f555c52f274b18efcd4d1b..3ffb83800e597998a36c29358c7421c93d1f62f4 100644
--- a/frameworks/native/audioadapter/include/pulse_audio_service_adapter_impl.h
+++ b/frameworks/native/audioadapter/include/pulse_audio_service_adapter_impl.h
@@ -56,6 +56,8 @@ public:
         DeviceType deviceType = DEVICE_TYPE_NONE) override { return 0; }
     int32_t GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray,
         DeviceType deviceType = DEVICE_TYPE_NONE) override { return 0; }
+    int32_t AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) override;
+    int32_t RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) override;
 
     // Static Member functions
     static void PaGetSinksCb(pa_context *c, const pa_sink_info *i, int eol, void *userdata);
diff --git a/frameworks/native/audioadapter/src/pro_audio_service_adapter_impl.cpp b/frameworks/native/audioadapter/src/pro_audio_service_adapter_impl.cpp
index 695f6dc90d0c80d9628307005ecc2ea205c1428f..ecbe5b716e2830c59eae3f5b6dd09dd66722c19e 100644
--- a/frameworks/native/audioadapter/src/pro_audio_service_adapter_impl.cpp
+++ b/frameworks/native/audioadapter/src/pro_audio_service_adapter_impl.cpp
@@ -569,6 +569,20 @@ int32_t ProAudioServiceAdapterImpl::SetSystemVolumeToEffect(AudioStreamType stre
     IHpaeManager::GetHpaeManager().SetEffectSystemVolume(streamType, volume);
     return SUCCESS;
 }
+
+int32_t ProAudioServiceAdapterImpl::AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    lock_guard<mutex> lock(lock_);
+    IHpaeManager::GetHpaeManager().AddCaptureInjector(sinkPortIndex, sourcePortIndex, sourceType);
+    return SUCCESS;
+}
+
+int32_t ProAudioServiceAdapterImpl::RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    lock_guard<mutex> lock(lock_);
+    IHpaeManager::GetHpaeManager().RemoveCaptureInjector(sinkPortIndex, sourcePortIndex, sourceType);
+    return SUCCESS;
+}
 }  // namespace AudioStandard
 }  // namespace OHOS
 
diff --git a/frameworks/native/audioadapter/src/pulse_audio_service_adapter_impl.cpp b/frameworks/native/audioadapter/src/pulse_audio_service_adapter_impl.cpp
index a192de6de9a93578c0be1fd864a451ddb9e07c02..59b23d66e1aca233765bbac378f5a99815e7d21f 100644
--- a/frameworks/native/audioadapter/src/pulse_audio_service_adapter_impl.cpp
+++ b/frameworks/native/audioadapter/src/pulse_audio_service_adapter_impl.cpp
@@ -957,6 +957,16 @@ void PulseAudioServiceAdapterImpl::PaSubscribeCb(pa_context *c, pa_subscription_
             break;
     }
 }
+
+int32_t PulseAudioServiceAdapterImpl::AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    return SUCCESS;
+}
+
+int32_t PulseAudioServiceAdapterImpl::RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    return SUCCESS;
+}
 } // namespace AudioStandard
 } // namespace OHOS
 
diff --git a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h
index 620da276f7b0a5fac1ffbca863fd848dcdde81f6..1b620502e8706b5d17b4168cd0bf88d34b2ce11f 100644
--- a/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h
+++ b/frameworks/native/audiodefinitions/include/audio_stream_descriptor.h
@@ -51,6 +51,7 @@ public:
     AudioStreamAction streamAction_ = AUDIO_STREAM_ACTION_DEFAULT;
     mutable std::vector<std::shared_ptr<AudioDeviceDescriptor>> oldDeviceDescs_ = {};
     mutable std::vector<std::shared_ptr<AudioDeviceDescriptor>> newDeviceDescs_ = {};
+    uint32_t target_ = 0;
     // for dup device
     mutable std::vector<std::shared_ptr<AudioDeviceDescriptor>> oldDupDeviceDescs_ = {};
     mutable std::vector<std::shared_ptr<AudioDeviceDescriptor>> newDupDeviceDescs_ = {};
diff --git a/frameworks/native/audiorenderer/src/audio_renderer.cpp b/frameworks/native/audiorenderer/src/audio_renderer.cpp
index 2fab083fa8353fa9ab809311f6cba419b9187ecc..49e5a949f5a48da23fda1cd7617dca45611af2c3 100644
--- a/frameworks/native/audiorenderer/src/audio_renderer.cpp
+++ b/frameworks/native/audiorenderer/src/audio_renderer.cpp
@@ -2304,6 +2304,7 @@ bool AudioRendererPrivate::GenerateNewStream(IAudioStream::StreamClass targetCla
     // Otherwise GetBufferDesc will return the buffer pointer of oldStream (causing Use-After-Free).
     UpdateRendererAudioStream(newAudioStream);
     newAudioStream->NotifyRouteUpdate(flag, networkId);
+    // newAudioStream->SetTarget(switchInfo.target);
 
     // Start new stream if old stream was in running state.
     // When restoring for audio server died, no need for restart.
diff --git a/frameworks/native/audiostream/include/i_audio_stream.h b/frameworks/native/audiostream/include/i_audio_stream.h
index 0f7ea1136617e1aa518872742d840f0b1e57d290..13ad1c72bc6613afe467aec9b5c857dff9d3a0d9 100644
--- a/frameworks/native/audiostream/include/i_audio_stream.h
+++ b/frameworks/native/audiostream/include/i_audio_stream.h
@@ -112,6 +112,7 @@ public:
         std::vector<std::pair<uint64_t, uint64_t>> lastFramePosAndTimePairWithSpeed = {
             Timestamp::Timestampbase::BASESIZE, {0, 0}
         };
+        uint32_t target = 0;
     };
 
     virtual ~IAudioStream() = default;
diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h
index 6ab761a85cf820cb3eec1fba3f6ad20ca605429a..b5f6d33b9c86244668e2dc397affc0c90bb83f5c 100644
--- a/interfaces/inner_api/native/audiocommon/include/audio_info.h
+++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h
@@ -88,6 +88,7 @@ const char* MODIFY_AUDIO_SETTINGS_PERMISSION = "ohos.permission.MODIFY_AUDIO_SET
 const char* ACCESS_NOTIFICATION_POLICY_PERMISSION = "ohos.permission.ACCESS_NOTIFICATION_POLICY";
 const char* CAPTURER_VOICE_DOWNLINK_PERMISSION = "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO";
 const char* RECORD_VOICE_CALL_PERMISSION = "ohos.permission.RECORD_VOICE_CALL";
+const char* INJECT_TO_AUDIO_CAPTURE = "ohos.permission.INJECT_TO_AUDIO_CAPTURE";
 
 const char* PRIMARY_WAKEUP = "Built_in_wakeup";
 const char* INNER_CAPTURER_SINK = "InnerCapturerSink_";
diff --git a/services/audio_policy/BUILD.gn b/services/audio_policy/BUILD.gn
index bc4bd63a6419981553b04df3dbadaab3da89c842..f4c2c6b1ee1304cee8b5886670191990c21f6bc2 100644
--- a/services/audio_policy/BUILD.gn
+++ b/services/audio_policy/BUILD.gn
@@ -282,6 +282,7 @@ audio_ohos_library("audio_policy_service") {
     "server/service/service_main/src/audio_core_service_utils.cpp",
     "server/domain/pipe/src/audio_pipe_manager.cpp",
     "server/domain/pipe/src/audio_pipe_selector.cpp",
+    "server/service/service_main/src/audio_injector_policy.cpp",
   ]
 
   defines = []
diff --git a/services/audio_policy/common/include/audio_service_enum.h b/services/audio_policy/common/include/audio_service_enum.h
index a8d3f6222ba3bfe7415e52a0034676673bc20fa3..725fc18f2c1d94c60dbe1b1e4f900cbb0f9f426a 100644
--- a/services/audio_policy/common/include/audio_service_enum.h
+++ b/services/audio_policy/common/include/audio_service_enum.h
@@ -29,6 +29,11 @@ enum SessionOperationMsg : uint32_t {
     SESSION_OP_MSG_DEFAULT = 0,
     SESSION_OP_MSG_REMOVE_PIPE = 1,
 };
+
+enum RendererTarget {
+    PLAYBACK_DEFAULT = 0,
+    INJECT_TO_VOICE_COMMUNICATION_CAPTURE = 1,
+};
 } // namespace AudioStandard
 } // namespace OHOS
 #endif // AUDIO_SERVICE_ENUM_H
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 69969bc7ebb0921151b8d051cc1ea89c4e7d9146..e59f6b660187d5035bd3d53fc089569d075873c8 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
@@ -88,6 +88,10 @@ public:
         uint32_t sessionId);
     bool IsStreamUsageActive(const StreamUsage &usage);
 
+    int32_t IsVoIPCall();
+    std::shared_ptr<AudioPipeInfo> GetPipeBySessionId(uint32_t sessionId);
+    uint32_t GetPaIndexByName(std::string portName);
+
 private:
     bool IsSpecialPipe(uint32_t routeFlag);
     bool IsNormalRecordPipe(std::shared_ptr<AudioPipeInfo> pipeInfo);
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 405609cf4fa79c01658a36fc2526930ff124f452..97b4706019f0e1ad45c03956445da63f05e2fa51 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
@@ -17,6 +17,7 @@
 #endif
 
 #include "audio_pipe_manager.h"
+#include "audio_injector_policy.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -597,5 +598,55 @@ bool AudioPipeManager::IsStreamUsageActive(const StreamUsage &usage)
     }
     return false;
 }
+
+int32_t AudioPipeManager::IsVoIPCall()
+{
+    std::shared_lock<std::shared_mutex> pLock(pipeListLock_);
+    for (auto it = curPipeList_.rbegin(); it != curPipeList_.rend(); ++it) {
+        if ((*it)->routeFlag_ & AUDIO_INPUT_FLAG_VOIP) {
+            AudioInjectorPolicy &audioInjectorPolicy = AudioInjectorPolicy::GetInstance();
+            audioInjectorPolicy.SetCapturePortIdx((*it)->paIndex_);
+            if ((*it)->routeFlag_ & AUDIO_INPUT_FLAG_NORMAL) {
+                return NORMAL_VOIP;
+            } else if ((*it)->routeFlag_ & AUDIO_INPUT_FLAG_FAST) {
+                return FAST_VOIP;
+            }
+        }
+    }
+    return NO_VOIP;
+}
+
+std::shared_ptr<AudioPipeInfo> AudioPipeManager::GetPipeBySessionId(uint32_t sessionId)
+{
+    std::unique_lock<std::shared_mutex> pLock(pipeListLock_);
+    for (const auto &pipe : curPipeList_) {
+        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 nullptr;
+}
+
+
+uint32_t AudioPipeManager::GetPaIndexByName(std::string portName)
+{
+    std::unique_lock<std::shared_mutex> pLock(pipeListLock_);
+    for (auto iter = curPipeList_.begin(); iter != curPipeList_.end(); iter++) {
+        CHECK_AND_CONTINUE_LOG((*iter) != nullptr, "iter is null");
+        if ((*iter)->name_ == portName) {
+            return (*iter)->paIndex_;
+        }
+    }
+    return HDI_INVALID_ID;
+}
 } // 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 34fc63c49973b52d43fdde6a20aaa2618b465ecf..a4df99fae0ba74bca925b705aab68161fe42008b 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
@@ -22,6 +22,8 @@
 #include "audio_definition_adapter_info.h"
 #include "audio_policy_utils.h"
 #include <algorithm>
+#include "audio_service_enum.h"
+#include "audio_injector_policy.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -165,13 +167,22 @@ void AudioPipeSelector::ProcessNewPipeList(std::vector<std::shared_ptr<AudioPipe
 {
     std::string adapterName{};
     for (auto &streamDesc : streamDescs) {
-        std::string streamDescAdapterName = GetAdapterNameByStreamDesc(streamDesc);
-        // find if curStream's prefer pipe has already exist
-        auto newPipeIter = std::find_if(newPipeInfoList.begin(), newPipeInfoList.end(),
-            [&](const std::shared_ptr<AudioPipeInfo> &newPipeInfo) {
-                return newPipeInfo->routeFlag_ == streamDesc->routeFlag_ &&
-                    newPipeInfo->adapterName_ == streamDescAdapterName;
-            });
+        std::vector<std::shared_ptr<AudioPipeInfo>>::iterator newPipeIter = newPipeInfoList.end();
+        if (streamDesc->target_ == INJECT_TO_VOICE_COMMUNICATION_CAPTURE) {
+            std::string streamDescAdapterName = AudioInjectorPolicy::GetInstance().GetAdapterName();
+            newPipeIter = std::find_if(newPipeInfoList.begin(), newPipeInfoList.end(),
+                [&](const std::shared_ptr<AudioPipeInfo> &newPipeInfo) {
+                    return newPipeInfo->adapterName_ == streamDescAdapterName;
+                });
+        } else {
+            std::string streamDescAdapterName = GetAdapterNameByStreamDesc(streamDesc);
+            // find if curStream's prefer pipe has already exist
+            newPipeIter = std::find_if(newPipeInfoList.begin(), newPipeInfoList.end(),
+                [&](const std::shared_ptr<AudioPipeInfo> &newPipeInfo) {
+                    return newPipeInfo->routeFlag_ == streamDesc->routeFlag_ &&
+                        newPipeInfo->adapterName_ == streamDescAdapterName;
+                });
+        }
         if (newPipeIter != newPipeInfoList.end()) {
             (*newPipeIter)->streamDescriptors_.push_back(streamDesc);
             (*newPipeIter)->streamDescMap_[streamDesc->sessionId_] = streamDesc;
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 fdcea314e5b64ae7016ebb79d12bf168806c631d..126f913f3e20e35c72f7cdf67a0c197c5612fd23 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
@@ -306,6 +306,11 @@ public:
     void SaveSystemVolumeForEffect(DeviceType deviceType, AudioStreamType streamType, int32_t volumeLevel);
     int32_t GetSystemVolumeForEffect(DeviceType deviceType, AudioStreamType streamType);
     int32_t SetSystemVolumeToEffect(AudioStreamType streamType, float volume);
+
+    int32_t AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType);
+    int32_t RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType);
+    int32_t AddCaptureInjector();
+    int32_t RemoveCaptureInjector();
 private:
     friend class PolicyCallbackImpl;
 
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 8be01d59d314be1f5d5a362d3d469df19b2b4dfb..248627bfffb99943312752e43127228d6faa7995 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
@@ -257,6 +257,11 @@ public:
 
     virtual float CalculateVolumeDbNonlinear(AudioStreamType streamType, DeviceType deviceType,
         int32_t volumeLevel) = 0;
+    
+    virtual int32_t AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) = 0;
+    virtual int32_t RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType) = 0;
+    virtual int32_t AddCaptureInjector() = 0;
+    virtual int32_t RemoveCaptureInjector() = 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 f47ba066b50627634bdc7cede2ea439596538161..6027bce4ad8d8d2741578736c2ecc058350de9bf 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
@@ -3405,6 +3405,35 @@ int32_t AudioAdapterManager::SetSystemVolumeToEffect(AudioStreamType streamType,
     CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_, ERROR, "audioServiceAdapter is null");
     return audioServiceAdapter_->SetSystemVolumeToEffect(streamType, volume);
 }
+
+int32_t AudioAdapterManager::AddCaptureInjector()
+{
+    AudioInjectorPolicy &audioInjectorPolicy = AudioInjectorPolicy::GetInstance();
+    AudioModuleInfo &info = audioInjectorPolicy.GetAudioModuleInfo();
+    uint32_t rendererPortIdx = audioInjectorPolicy.GetRendererPortIdx();
+    CHECK_AND_RETURN_RET_LOG(audioServerProxy_ != nullptr, ERROR, "audioServerProxy_ null");
+    return audioServerProxy_->AddCaptureInjector(rendererPortIdx, info.rate, info.format, info.channels);
+}
+
+int32_t AudioAdapterManager::RemoveCaptureInjector()
+{
+    AudioInjectorPolicy &audioInjectorPolicy = AudioInjectorPolicy::GetInstance();
+    uint32_t rendererPortIdx = audioInjectorPolicy.GetRendererPortIdx();
+    CHECK_AND_RETURN_RET_LOG(audioServerProxy_ != nullptr, ERROR, "audioServerProxy_ null");
+    return audioServerProxy_->RemoveCaptureInjector(rendererPortIdx);
+}
+
+int32_t AudioAdapterManager::AddCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_ != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
+    return audioServiceAdapter_->AddCaptureInjector(sinkPortIndex, sourcePortIndex, sourceType);
+}
+
+int32_t AudioAdapterManager::RemoveCaptureInjector(const uint32_t &sinkPortIndex, const uint32_t &sourcePortIndex, const SourceType &sourceType)
+{
+    CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_ != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
+    return audioServiceAdapter_->RemoveCaptureInjector(sinkPortIndex, sourcePortIndex, sourceType);
+}
 // LCOV_EXCL_STOP
 } // namespace AudioStandard
 } // namespace OHOS
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 5aee838b5070432a640ed5190ba9f92e6e0fc5e2..fe815cd1fabf7ad45ed4e9c5c53424b005162d52 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
@@ -48,6 +48,7 @@
 #include "audio_event_utils.h"
 #include "audio_stream_id_allocator.h"
 #include "i_hpae_soft_link.h"
+#include "audio_injector_policy.h"
 namespace OHOS {
 namespace AudioStandard {
 enum OffloadType {
@@ -177,6 +178,8 @@ public:
         std::vector<sptr<VolumeGroupInfo>> GetVolumeGroupInfos();
         int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config) override;
         int32_t ReleaseOffloadPipe(AudioIOHandle id, uint32_t paIndex, OffloadType type);
+        int32_t SetRendererTarget(RendererTarget target, RendererTarget lastTarget, uint32_t sessionId) override;
+        int32_t StartInjection(uint32_t sessionId) override;
 private:
         std::shared_ptr<AudioCoreService> coreService_;
         std::shared_mutex eventMutex_;
@@ -318,6 +321,8 @@ private:
     void SetFirstScreenOn();
     void FetchOutputDupDevice(std::string caller, uint32_t sessionId,
         std::shared_ptr<AudioStreamDescriptor> &streamDesc);
+    int32_t SetRendererTarget(RendererTarget target, RendererTarget lastTarget, uint32_t sessionId);
+    int32_t StartInjection(uint32_t sessionId);
 private:
     static std::string GetEncryptAddr(const std::string &addr);
     int32_t FetchRendererPipesAndExecute(std::vector<std::shared_ptr<AudioStreamDescriptor>> &streamDescs,
@@ -523,6 +528,9 @@ private:
     void CheckOpenHearingAidCall(const bool isModemCallRunning, const DeviceType type);
     std::shared_ptr<AudioDeviceDescriptor> GetCaptureClientDevice(
         std::shared_ptr<AudioStreamDescriptor> streamDesc, uint32_t sessionId);
+    
+    int32_t PlayBackToInjection(uint32_t sessionId);
+    int32_t InjectionToPlayBack(uint32_t sessionId);
 
 private:
     std::shared_ptr<EventEntry> eventEntry_;
@@ -609,6 +617,8 @@ private:
         .type = CAST_TYPE_NULL
     };
     bool isFirstScreenOn_ = false;
+
+    AudioInjectorPolicy &audioInjectorPolicy_;
 };
 }
 }
diff --git a/services/audio_policy/server/service/service_main/include/audio_injector_policy.h b/services/audio_policy/server/service/service_main/include/audio_injector_policy.h
new file mode 100644
index 0000000000000000000000000000000000000000..c56c80c7929b2358e421c7296b7ea7d99eaa7f79
--- /dev/null
+++ b/services/audio_policy/server/service/service_main/include/audio_injector_policy.h
@@ -0,0 +1,74 @@
+/*
+ * 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_INJECTOR_POLICY_H
+#define AUDIO_INJECTOR_POLICY_H
+
+#include <set>
+#include "audio_module_info.h"
+#include "audio_pipe_info.h"
+#include "audio_iohandle_map.h"
+#include "iaudio_policy_interface.h"
+#include "audio_pipe_manager.h"
+#include "audio_service_enum.h"
+
+namespace OHOS {
+namespace AudioStandard {
+enum VoIpType {
+    NO_VOIP = 0,
+    NORMAL_VOIP = 1,
+    FAST_VOIP = 2,
+};
+
+class AudioInjectorPolicy {
+public:
+    static AudioInjectorPolicy& GetInstance()
+    {
+        static AudioInjectorPolicy instance;
+        return instance;
+    }
+    int32_t Init();
+    int32_t DeInit();
+    int32_t UpdateAudioInfo(AudioModuleInfo &info);
+    int32_t MoveStreamIn(uint32_t renderId);
+    int32_t MoveStreamOut(uint32_t renderId, RendererTarget target);
+    bool IsContainStream(uint32_t renderId);
+    std::string GetAdapterName();
+    int32_t GetRendererStreamCount();
+    void SetCapturePortIdx(uint32_t idx);
+    uint32_t GetCapturePortIdx();
+    void SetRendererPortIdx(uint32_t idx);
+    uint32_t GetRendererPortIdx();
+    AudioModuleInfo& GetAudioModuleInfo();
+    int32_t AddCaptureInjector();
+    int32_t RemoveCaptureInjector();
+
+private:
+    AudioInjectorPolicy();
+    AudioInjectorPolicy(const AudioInjectorPolicy&) = delete;
+    AudioInjectorPolicy& operator=(const AudioInjectorPolicy&) = delete;
+private:
+    AudioModuleInfo moduleInfo_;
+    uint32_t capturePortIdx_;
+    uint32_t renderPortIdx_;
+    bool isConnected_;
+    std::unordered_map<uint32_t, std::shared_ptr<AudioStreamDescriptor>> rendererStreamMap_ = {};
+    AudioIOHandleMap &audioIOHandleMap_;
+    IAudioPolicyInterface &audioPolicyManager_;
+    std::shared_ptr<AudioPipeManager> pipeManager_ = nullptr;
+    std::shared_mutex injectLock_;
+};
+} //  namespace AudioStandard
+} //  namespace OHOS
+#endif  // AUDIO_INJECTOR_POLICY_H
\ No newline at end of file
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 9515f906c209fc7f220d681b896fa77b4a678227..297db7103fb10f8022e85c8b5a39f9459e5fd300 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
@@ -83,7 +83,8 @@ AudioCoreService::AudioCoreService()
       audioUsrSelectManager_(AudioUsrSelectManager::GetAudioUsrSelectManager()),
       audioPipeSelector_(AudioPipeSelector::GetPipeSelector()),
       audioSessionService_(AudioSessionService::GetAudioSessionService()),
-      pipeManager_(AudioPipeManager::GetPipeManager())
+      pipeManager_(AudioPipeManager::GetPipeManager()),
+      audioInjectorPolicy_(AudioInjectorPolicy::GetInstance())
 {
     AUDIO_INFO_LOG("Ctor");
 }
@@ -1519,5 +1520,30 @@ void AudioCoreService::SetFirstScreenOn()
 {
     isFirstScreenOn_ = true;
 }
+
+int32_t AudioCoreService::SetRendererTarget(RendererTarget target, RendererTarget lastTarget, uint32_t sessionId)
+{
+    int32_t ret = ERROR;
+    if (lastTarget == PLAYBACK_DEFAULT && target == INJECT_TO_VOICE_COMMUNICATION_CAPTURE) {
+        ret = PlayBackToInjection(sessionId);
+    } else if(lastTarget == INJECT_TO_VOICE_COMMUNICATION_CAPTURE && target == PLAYBACK_DEFAULT) {
+        ret = InjectionToPlayBack(sessionId);
+    }
+    return ret;
+}
+
+int32_t AudioCoreService::StartInjection(uint32_t streamId)
+{
+    CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERR_NULL_POINTER, "pipeManager_ is null");
+    if (pipeManager_->IsVoIPCall() == NO_VOIP) {
+        return ERROR;
+    }
+    int32_t ret = ERROR;
+    ret = audioInjectorPolicy_.AddCaptureInjector();
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "AddCaptureInjector failed");
+    ret = audioInjectorPolicy_.MoveStreamIn(streamId);
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "Move Stream in failed");
+    return SUCCESS;
+}
 } // namespace AudioStandard
 } // namespace OHOS
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 f049bb588fc5f22bdd83c024ee19e26a3f61a6fb..102b20648c787f25179a58597cd19a70a650f7b7 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
@@ -599,5 +599,17 @@ int32_t AudioCoreService::EventEntry::ReleaseOffloadPipe(AudioIOHandle id, uint3
     coreService_->isOffloadInRelease_[type].store(false);
     return SUCCESS;
 }
+
+int32_t AudioCoreService::EventEntry::SetRendererTarget(RendererTarget target, RendererTarget lastTarget, uint32_t sessionId)
+{
+    std::lock_guard<std::shared_mutex> lock(eventMutex_);
+    return coreService_->SetRendererTarget(target, lastTarget, sessionId);
+}
+
+int32_t AudioCoreService::EventEntry::StartInjection(uint32_t sessionId)
+{
+    std::lock_guard<std::shared_mutex> lock(eventMutex_);
+    return coreService_->StartInjection(sessionId);
+}
 }
 }
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 0c8963750e758fb3960c625a411b0530be91fc8f..36d269c237074ab2a01a162584717adbd37c8094 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
@@ -3144,5 +3144,31 @@ int32_t AudioCoreService::SetSleVoiceStatusFlag(AudioScene audioScene)
     }
     return SUCCESS;
 }
+
+int32_t AudioCoreService::PlayBackToInjection(uint32_t sessionId)
+{
+    auto tokenId = IPCSkeleton::GetCallingTokenID();
+    if (!PermissionUtil::VerifyPermission(INJECT_TO_AUDIO_CAPTURE, tokenId)) {
+        return ERR_PERMISSION_DENIED;
+    }
+    if (pipeManager_->IsVoIPCall() == NO_VOIP) {
+        return ERROR;
+    }
+    int32_t ret = audioInjectorPolicy_.Init();
+    //策略
+    return ret;
+}
+
+int32_t AudioCoreService::InjectionToPlayBack(uint32_t sessionId)
+{
+    int32_t ret = ERROR;
+    ret = audioInjectorPolicy_.MoveStreamOut(sessionId, PLAYBACK_DEFAULT);
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "Move Stream out failed");
+    ret = audioInjectorPolicy_.RemoveCaptureInjector();
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "RemoveCaptureInjector failed");
+    ret = audioInjectorPolicy_.DeInit();
+     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "DeInit failed");
+    return SUCCESS;
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_policy/server/service/service_main/src/audio_injector_policy.cpp b/services/audio_policy/server/service/service_main/src/audio_injector_policy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..faf16309435a5ca780e00a5206fe58549023dac0
--- /dev/null
+++ b/services/audio_policy/server/service/service_main/src/audio_injector_policy.cpp
@@ -0,0 +1,185 @@
+/*
+ * 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_injector_policy.h"
+#include "audio_policy_manager_factory.h"
+#include "audio_core_service.h"
+#include "audio_device_info.h"
+
+namespace OHOS {
+namespace AudioStandard {
+AudioInjectorPolicy::AudioInjectorPolicy()
+    :audioIOHandleMap_(AudioIOHandleMap::GetInstance()),
+     audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager())
+{
+    pipeManager_ = AudioPipeManager::GetPipeManager();
+    isConnected_ = false;
+}
+
+int32_t AudioInjectorPolicy::Init()
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    if (rendererStreamMap_.size() == 0) {
+        AUDIO_INFO_LOG("Start");
+        AudioModuleInfo moduleInfo = {};
+        moduleInfo.lib = "libmodule-hdi-sink.z.so";
+        std::string name = "";
+        moduleInfo.name = name;
+        moduleInfo.deviceType = "SYSTEM_PRIVATE";
+        moduleInfo.format = "s16le";
+        moduleInfo.channels = "2"; // 2 channel
+        moduleInfo.rate = "48000";
+        moduleInfo.bufferSize = "3840"; // 20ms
+
+        int32_t ret = audioIOHandleMap_.OpenPortAndInsertIOHandle(moduleInfo.name, moduleInfo);
+        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "open port failed");
+        this->moduleInfo_ = moduleInfo;
+        CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERROR, "pipeManager_ is null");
+        renderPortIdx_ = pipeManager_->GetPaIndexByName(moduleInfo.name);
+        CHECK_AND_RETURN_RET_LOG(renderPortIdx_ != HDI_INVALID_ID, ERROR, "renderPortIdx error!");
+    }
+    return SUCCESS;
+}
+
+int32_t AudioInjectorPolicy::DeInit()
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    if (rendererStreamMap_.size() == 0) {
+        int32_t ret = audioIOHandleMap_.ClosePortAndEraseIOHandle(moduleInfo_.name);
+        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "close port failed");
+        renderPortIdx_ = HDI_INVALID_ID;
+    }
+    return SUCCESS;
+}
+
+int32_t AudioInjectorPolicy::UpdateAudioInfo(AudioModuleInfo &info)
+{
+    return SUCCESS;
+}
+
+int32_t AudioInjectorPolicy::MoveStreamIn(uint32_t renderId)
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERROR, "pipeManager_ is null");
+    std::shared_ptr<AudioStreamDescriptor> streamDesc = pipeManager_->GetStreamDescById(renderId);
+    CHECK_AND_RETURN_RET_LOG(streamDesc != nullptr, ERROR, "get streamDesc failed");
+    streamDesc->target_ = PLAYBACK_DEFAULT;
+    int32_t ret = AudioCoreService::GetCoreService()->FetchOutputDeviceAndRoute("OnForcedDeviceSelected",
+        AudioStreamDeviceChangeReasonExt::ExtEnum::OVERRODE);
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "move stream in failed");
+    rendererStreamMap_[renderId] = streamDesc;
+    return SUCCESS;
+}
+
+int32_t AudioInjectorPolicy::MoveStreamOut(uint32_t renderId, RendererTarget target)
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERROR, "pipeManager_ is null");
+    std::shared_ptr<AudioStreamDescriptor> streamDesc = pipeManager_->GetStreamDescById(renderId);
+    CHECK_AND_RETURN_RET_LOG(streamDesc != nullptr, ERROR, "get streamDesc failed");
+    streamDesc->target_ = target;
+    int32_t ret = AudioCoreService::GetCoreService()->FetchOutputDeviceAndRoute("OnForcedDeviceSelected",
+        AudioStreamDeviceChangeReasonExt::ExtEnum::OVERRODE);
+    CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "move stream out failed");
+    rendererStreamMap_[renderId] = nullptr;
+    rendererStreamMap_.erase(renderId);
+    return SUCCESS;
+}
+
+bool AudioInjectorPolicy::IsContainStream(uint32_t renderId)
+{
+    auto streamIt = rendererStreamMap_.find(renderId);
+    if (streamIt != rendererStreamMap_.end()) {
+        return true; 
+    }
+    return false;
+}
+
+std::string AudioInjectorPolicy::GetAdapterName()
+{
+    return moduleInfo_.name;
+}
+
+// get the number of rendererStream moved in Injector
+int32_t AudioInjectorPolicy::GetRendererStreamCount()
+{
+    return rendererStreamMap_.size();
+}
+
+void AudioInjectorPolicy::SetCapturePortIdx(uint32_t idx)
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    capturePortIdx_ = idx;
+}
+
+uint32_t AudioInjectorPolicy::GetCapturePortIdx()
+{
+    return capturePortIdx_;
+}
+
+void AudioInjectorPolicy::SetRendererPortIdx(uint32_t idx)
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    renderPortIdx_ = idx;
+}
+
+uint32_t AudioInjectorPolicy::GetRendererPortIdx()
+{
+    return renderPortIdx_;
+}
+
+AudioModuleInfo& AudioInjectorPolicy::GetAudioModuleInfo()
+{
+    return moduleInfo_;
+}
+
+int32_t AudioInjectorPolicy::AddCaptureInjector()
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    int32_t ret = ERROR;
+    if (!isConnected_) {
+        CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERROR, "pipeManager_ is null");
+        if (pipeManager_->IsVoIPCall() == NORMAL_VOIP) {
+            ret = audioPolicyManager_.AddCaptureInjector(renderPortIdx_, capturePortIdx_, SOURCE_TYPE_VOICE_COMMUNICATION);
+        } else if (pipeManager_->IsVoIPCall() == FAST_VOIP) {
+            ret = audioPolicyManager_.AddCaptureInjector();
+        }
+        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "AddCaptureInjector failed");
+        isConnected_ = true;
+    }
+    return SUCCESS;
+}
+    
+int32_t AudioInjectorPolicy::RemoveCaptureInjector()
+{
+    std::lock_guard<std::shared_mutex> lock(injectLock_);
+    int32_t ret = ERROR;
+<<<<<<< HEAD
+    if (isConnected_ && rendererStreamMap_.size() == 0) {
+=======
+    if (isConnected_) {
+>>>>>>> 1f041a2b7467dfd740c9f1dedb6373a43ea0e5ac
+        CHECK_AND_RETURN_RET_LOG(pipeManager_ != nullptr, ERROR, "pipeManager_ is null");
+        if (pipeManager_->IsVoIPCall() == NORMAL_VOIP) {
+            ret = audioPolicyManager_.RemoveCaptureInjector(renderPortIdx_, capturePortIdx_, SOURCE_TYPE_VOICE_COMMUNICATION);
+        } else if (pipeManager_->IsVoIPCall() == FAST_VOIP) {
+            ret = audioPolicyManager_.RemoveCaptureInjector();
+        }
+        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "RemoveCaptureInjector failed");
+        isConnected_ = false;
+    }
+    return SUCCESS;
+}
+}  //  namespace AudioStandard
+}  //  namespace OHOS
\ No newline at end of file
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 cd8ef6a536b67cfaff92105ef05212212fb5144f..9dfb67c0ad065389762b46dd5e26da847fbac4f2 100644
--- a/services/audio_service/client/include/core_service_provider_stub.h
+++ b/services/audio_service/client/include/core_service_provider_stub.h
@@ -37,6 +37,8 @@ public:
     int32_t GetPaIndexByPortName(const std::string &portName, uint32_t &ret) override;
 
     int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config, int32_t &ret) override;
+    int32_t SetRendererTarget(uint32_t target, uint32_t lastTarget, uint32_t sessionId, int32_t &ret) override;
+    int32_t StartInjection(uint32_t streamId, int32_t &ret) 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 e847917ac8e8f2ed8ac1a2eaa7bb8939e379fb76..765bbac205ea2fac65d8ae62245b5dafbf5cf417 100644
--- a/services/audio_service/client/include/renderer_in_client_private.h
+++ b/services/audio_service/client/include/renderer_in_client_private.h
@@ -502,6 +502,8 @@ private:
     std::optional<pid_t> lastCallStartByUserTid_ = std::nullopt;
 
     std::function<uid_t()> uidGetter_ = [] { return getuid(); };
+
+    uint32_t target_ = 0;
 };
 
 class SpatializationStateChangeCallbackImpl : public AudioSpatializationStateChangeCallback {
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 d112abf64f1cb07a3c1eb4ee7fda114cd04d1042..7dfbecbed2af5b53f7eeb4c939104fbd117a915c 100644
--- a/services/audio_service/client/src/core_service_provider_stub.cpp
+++ b/services/audio_service/client/src/core_service_provider_stub.cpp
@@ -89,5 +89,19 @@ int32_t CoreServiceProviderWrapper::GetPaIndexByPortName(const std::string &port
     ret = coreServiceWorker_->GetPaIndexByPortName(portName);
     return SUCCESS;
 }
+
+int32_t CoreServiceProviderWrapper::SetRendererTarget(uint32_t target, uint32_t lastTarget, uint32_t sessionId, int32_t &ret)
+{
+    CHECK_AND_RETURN_RET_LOG(coreServiceWorker_ != nullptr, AUDIO_INIT_FAIL, "coreServiceWorker_ is null");
+    ret = coreServiceWorker_->SetRendererTarget(static_cast<RendererTarget>(target), static_cast<RendererTarget>(lastTarget), sessionId);
+    return SUCCESS;
+}
+
+int32_t CoreServiceProviderWrapper::StartInjection(uint32_t streamId, int32_t &ret)
+{
+    CHECK_AND_RETURN_RET_LOG(coreServiceWorker_ != nullptr, AUDIO_INIT_FAIL, "coreServiceWorker_ is null");
+    ret = coreServiceWorker_->StartInjection(streamId);
+    return SUCCESS;
+}
 } // namespace AudioStandard
 } // namespace OHOS
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 a25ba3773fab079e3023678b7d93fe7590aed4bf..d4234712323eb24bada0c32a7a05f850684e160d 100644
--- a/services/audio_service/client/src/renderer_in_client_public.cpp
+++ b/services/audio_service/client/src/renderer_in_client_public.cpp
@@ -1468,6 +1468,7 @@ void RendererInClientInner::GetSwitchInfo(IAudioStream::SwitchInfo& info)
     info.defaultOutputDevice = defaultOutputDevice_;
     info.lastFramePosAndTimePair = lastFramePosAndTimePair_;
     info.lastFramePosAndTimePairWithSpeed = lastFramePosAndTimePairWithSpeed_;
+    info.target = target_;
     GetStreamSwitchInfo(info);
 
     {
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 73a9ff372b351d0dc7bef1b6f46acd346af92da7..6b1fb3c43873a5f097a5a75fcba530c7e2c32c1c 100644
--- a/services/audio_service/common/include/i_core_service_provider.h
+++ b/services/audio_service/common/include/i_core_service_provider.h
@@ -39,6 +39,8 @@ public:
     virtual int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config) = 0;
 
     virtual ~ICoreServiceProvider() = default;
+    virtual int32_t SetRendererTarget(RendererTarget target, RendererTarget lastTarget, uint32_t sessionId) = 0;
+    virtual int32_t StartInjection(uint32_t sessionId) = 0;
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/idl/ICoreServiceProviderIpc.idl b/services/audio_service/idl/ICoreServiceProviderIpc.idl
index bf7d9f9b9453b35e4f3f264177fd7d5e702728a1..ec1215f420ecb3fb1d203dcd4ceafb3298a44510 100644
--- a/services/audio_service/idl/ICoreServiceProviderIpc.idl
+++ b/services/audio_service/idl/ICoreServiceProviderIpc.idl
@@ -47,4 +47,12 @@ interface ICoreServiceProviderIpc {
     void GetPaIndexByPortName(
         [in] String portName,
         [out] unsigned int ret);
+    void SetRendererTarget(
+        [in] unsigned int target,
+        [in] unsigned int lastTarget,
+        [in] unsigned int sessionId,
+        [out] int ret);
+    void StartInjection(
+        [in] unsigned int target,
+        [out] int ret);
 }
diff --git a/services/audio_service/idl/IStandardAudioService.idl b/services/audio_service/idl/IStandardAudioService.idl
index 83b9f171d2f8c3279d1d83859979b652c83b9fa4..82678d0f93aa079a6020a7381a50619af8b668a0 100644
--- a/services/audio_service/idl/IStandardAudioService.idl
+++ b/services/audio_service/idl/IStandardAudioService.idl
@@ -140,6 +140,8 @@ interface IStandardAudioService {
     void RestoreAudioWorkgroupPrio([in] int pid, [in] Map<int, int> threads);
     void SetRenderWhitelist([in] List<String> list);
     void GetVolumeBySessionId([in] unsigned int sessionId, [out] float volume);
+    void AddCaptureInjector([in] unsigned int sinkPortidx, [out] String rate, [out] String format, [out] String channels);
+    void RemoveCaptureInjector([in] unsigned int sinkPortidx);
     // WARNING: above functions correspond with AudioServerInterfaceCode
 
     // undefined in AudioServerInterfaceCode
diff --git a/services/audio_service/server/include/audio_injector_service.h b/services/audio_service/server/include/audio_injector_service.h
index 0b5dd8c84f76d25f4cffabdf40853c4e762c229f..2b4cd02e0eb89935f85c1967a9cd111fbcfe6de8 100644
--- a/services/audio_service/server/include/audio_injector_service.h
+++ b/services/audio_service/server/include/audio_injector_service.h
@@ -33,10 +33,11 @@ public:
     int32_t GetSinkPortIdx();
 private:
     AudioInjectorService();
+    ~AudioInjectorService() = default;
     AudioInjectorService(const AudioInjectorService&) = delete;
     AudioInjectorService& operator=(const AudioInjectorService&) = delete;
 private:
-    AudioModuleInfo moudleInfo_;
+    AudioModuleInfo moduleInfo_;
     uint32_t sinkPortIndex_;
 };
 } //  namespace AudioStandard
diff --git a/services/audio_service/server/include/audio_server.h b/services/audio_service/server/include/audio_server.h
index 93462af2eabc6b26d218fc3f831c4b6b4c8b4065..ae608d1290a7cf2985aa374ae7e07d65b630ab10 100644
--- a/services/audio_service/server/include/audio_server.h
+++ b/services/audio_service/server/include/audio_server.h
@@ -270,6 +270,9 @@ public:
     int32_t SendInterruptEventToAudioServer(uint32_t sessionId,
         const InterruptEventInternal &interruptEvent) override;
     int32_t GetVolumeBySessionId(uint32_t sessionId, float &volume) override;
+
+    int32_t AddCaptureInjector(uint32_t sinkPortidx, std::string &rate, std::string &format, std::string &channels) override;
+    int32_t RemoveCaptureInjector(uint32_t sinkPortidx) override;
 protected:
     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
 
diff --git a/services/audio_service/server/include/core_service_handler.h b/services/audio_service/server/include/core_service_handler.h
index 68ed4c89b23918fac5d31cb95a4b43f221aeace4..fa44b86fe8631662dc688fa68e94a66216798a22 100644
--- a/services/audio_service/server/include/core_service_handler.h
+++ b/services/audio_service/server/include/core_service_handler.h
@@ -47,6 +47,9 @@ public:
         AudioStreamInfo &streamInfo, bool isReloadProcess);
     uint32_t GenerateSessionId();
     int32_t SetWakeUpAudioCapturerFromAudioServer(const AudioProcessConfig &config);
+
+    int32_t SetRendererTarget(uint32_t target, uint32_t lastTarget, uint32_t sessionId);
+    int32_t StartInjection(uint32_t sessionId);
 private:
     CoreServiceHandler();
     sptr<ICoreServiceProviderIpc> iCoreServiceProvider_ = nullptr;
diff --git a/services/audio_service/server/include/renderer_in_server.h b/services/audio_service/server/include/renderer_in_server.h
index 5208dc16983e7f5fb733abd5ecf75927df8f9a92..ff1bed1ec945364a3ca87750171636c96222cd7d 100644
--- a/services/audio_service/server/include/renderer_in_server.h
+++ b/services/audio_service/server/include/renderer_in_server.h
@@ -26,6 +26,7 @@
 #include "audio_stream_monitor.h"
 #include "audio_stream_checker.h"
 #include "player_dfx_writer.h"
+#include "audio_service_enum.h"
 
 namespace OHOS {
 namespace AudioStandard {
@@ -151,6 +152,7 @@ public:
     int32_t InitSoftLink(int32_t innerCapId);
     int32_t DestroySoftLink(int32_t innerCapId);
     int32_t InitSoftLinkVolume(std::shared_ptr<HPAE::IHpaeSoftLink> softLinkPtr);
+    int32_t SetTarget(RendererTarget target, int32_t &ret);
 public:
     const AudioProcessConfig processConfig_;
 private:
@@ -287,6 +289,8 @@ private:
 
     std::unordered_map<int32_t, SoftLinkInfo> softLinkInfos_;
     FILE *dumpSoftLink = nullptr;
+
+    RendererTarget lastTarget_;
 };
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/server/src/audio_injector_service.cpp b/services/audio_service/server/src/audio_injector_service.cpp
index a106310563e2a8abad0d2116fee4eb9352ac65f5..f7328b8994f82b4b28af2f76ddccc2ee60cc3fd2 100644
--- a/services/audio_service/server/src/audio_injector_service.cpp
+++ b/services/audio_service/server/src/audio_injector_service.cpp
@@ -13,22 +13,26 @@
  * limitations under the License.
  */
 #include "audio_injector_service.h"
+#include "i_hpae_manager.h"
+#include "audio_errors.h"
 
 namespace OHOS {
 namespace AudioStandard {
-AudioInjectorService::AudioInjectorService()
+AudioInjectorService::AudioInjectorService() 
 {
 }
 
 int32_t AudioInjectorService::UpdateAudioInfo(AudioModuleInfo &info)
 {
-    return 0;
+    HPAE::IHpaeManager::GetHpaeManager().UpdateAudioPortInfo(sinkPortIndex_, info);
+    return SUCCESS;
 }
 
 int32_t AudioInjectorService::PeekAudioData(const uint32_t sinkPortIndex, uint8_t *buffer, const size_t bufferSize,
     AudioStreamInfo &streamInfo)
 {
-    return 0;
+    HPAE::IHpaeManager::GetHpaeManager().PeekAudioData(sinkPortIndex, buffer, bufferSize, streamInfo);
+    return SUCCESS;
 }
 
 void AudioInjectorService::SetSinkPortIdx(uint32_t sinkPortIdx)
diff --git a/services/audio_service/server/src/audio_server.cpp b/services/audio_service/server/src/audio_server.cpp
index fe72497d9914196b6e3b2097039000c3f1888cce..10d0376372d484f7ec3361937905b34b0c7d87ea 100644
--- a/services/audio_service/server/src/audio_server.cpp
+++ b/services/audio_service/server/src/audio_server.cpp
@@ -3168,6 +3168,18 @@ int32_t AudioServer::GetPrivacyTypeAudioServer(uint32_t sessionId, int32_t &priv
     privacyType = static_cast<int32_t>(type);
     return SUCCESS;
 }
+
+int32_t AudioServer::AddCaptureInjector(uint32_t sinkPortidx, std::string &rate, std::string &format, std::string &channels)
+{
+    //endpoint::AddCaptureInjector
+    return SUCCESS;
+}
+
+int32_t AudioServer::RemoveCaptureInjector(uint32_t sinkPortidx)
+{
+    //endpoint::RemoveCaptureInjector
+    return SUCCESS;
+}
 // 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 7534d09176cf5aff0b9ea13b67fde139516c739e..0ca3a81c454f7698036f793ca765abb955693815 100644
--- a/services/audio_service/server/src/core_service_handler.cpp
+++ b/services/audio_service/server/src/core_service_handler.cpp
@@ -114,5 +114,21 @@ uint32_t CoreServiceHandler::GetPaIndexByPortName(const std::string &portName)
     iCoreServiceProvider_->GetPaIndexByPortName(portName, ret);
     return ret;
 }
+
+int32_t CoreServiceHandler::SetRendererTarget(uint32_t target, uint32_t lastTarget, uint32_t sessionId)
+{
+    CHECK_AND_RETURN_RET_LOG(iCoreServiceProvider_ != nullptr, ERROR, "iCoreServiceProvider_ is nullptr!");
+    int32_t ret = ERROR;
+    iCoreServiceProvider_->SetRendererTarget(target, lastTarget, sessionId, ret);
+    return ret;
+}
+
+int32_t CoreServiceHandler::StartInjection(uint32_t sessionId)
+{
+    CHECK_AND_RETURN_RET_LOG(iCoreServiceProvider_ != nullptr, ERROR, "iCoreServiceProvider_ is nullptr!");
+    int32_t ret = ERROR;
+    iCoreServiceProvider_->StartInjection(sessionId, ret);
+    return ret;
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/server/src/renderer_in_server.cpp b/services/audio_service/server/src/renderer_in_server.cpp
index e49341db395011d4a91eee0ef966602b5d0545ed..be202d1f22785347099a3511945a1ec0a3b16bad 100644
--- a/services/audio_service/server/src/renderer_in_server.cpp
+++ b/services/audio_service/server/src/renderer_in_server.cpp
@@ -1003,6 +1003,10 @@ int32_t RendererInServer::StartInner()
 {
     AUDIO_INFO_LOG("sessionId: %{public}u", streamIndex_);
     int32_t ret = 0;
+    if (lastTarget_ == INJECT_TO_VOICE_COMMUNICATION_CAPTURE) {
+        ret = CoreServiceHandler::GetInstance().StartInjection(streamIndex_);
+        CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "StartInjection failed");
+    }
     if (standByEnable_) {
         return StartInnerDuringStandby();
     } else {
@@ -2474,5 +2478,20 @@ bool RendererInServer::IsMovieStream()
     return processConfig_.streamType == STREAM_MOVIE &&
     processConfig_.rendererInfo.originalFlag == AUDIO_FLAG_PCM_OFFLOAD;
 }
+
+int32_t RendererInServer::SetTarget(RendererTarget target, int32_t &ret)
+{
+    if (target == lastTarget_) {
+        ret = SUCCESS;
+        return ret;
+    }
+    if (status_ == I_STATUS_IDLE || status_ == I_STATUS_PAUSED || status_ == I_STATUS_STOPPED) {
+        ret = CoreServiceHandler::GetInstance().SetRendererTarget(target, lastTarget_, streamIndex_);
+        lastTarget_ = target;
+        return ret;
+    }
+    ret = ERR_ILLEGAL_STATE;
+    return ret;
+}
 } // namespace AudioStandard
 } // namespace OHOS