diff --git a/frameworks/js/napi/audiorenderer/napi_audio_renderer.cpp b/frameworks/js/napi/audiorenderer/napi_audio_renderer.cpp
index 6f69353376a7851c696949beea8b8150a6550ee3..907b6ab60c54a45760701d8aa58be3f359c01b85 100644
--- a/frameworks/js/napi/audiorenderer/napi_audio_renderer.cpp
+++ b/frameworks/js/napi/audiorenderer/napi_audio_renderer.cpp
@@ -121,6 +121,8 @@ napi_status NapiAudioRenderer::InitNapiAudioRenderer(napi_env env, napi_value &c
         DECLARE_NAPI_FUNCTION("getAudioTimestampInfo", GetAudioTimestampInfo),
         DECLARE_NAPI_FUNCTION("getAudioTimestampInfoSync", GetAudioTimestampInfoSync),
         DECLARE_NAPI_FUNCTION("setDefaultOutputDevice", SetDefaultOutputDevice),
+        DECLARE_NAPI_FUNCTION("setTarget", SetTarget),
+        DECLARE_NAPI_FUNCTION("getTarget", GetTarget),
     };
 
     napi_status status = napi_define_class(env, NAPI_AUDIO_RENDERER_CLASS_NAME.c_str(),
@@ -551,6 +553,74 @@ napi_value NapiAudioRenderer::GetRendererSamplingRate(napi_env env, napi_callbac
     return NapiAsyncWork::Enqueue(env, context, "GetRendererSamplingRate", executor, complete);
 }
 
+napi_value NapiAudioRenderer::SetTarget(napi_env env, napi_callback_info info)
+{
+    CHECK_AND_RETURN_RET_LOG(PermissionUtil::VerifySelfPermission(),
+        NapiAudioError::ThrowErrorAndReturn(env, NAPI_ERR_PERMISSION_DENIED), "No system permission");
+    auto context = std::make_shared<AudioRendererAsyncContext>();
+    if (context == nullptr) {
+        AUDIO_ERR_LOG("SetTarget failed : no memory");
+        NapiAudioError::ThrowError(env, "SetTarget failed : no memory",
+            NAPI_ERR_NO_MEMORY);
+        return NapiParamUtils::GetUndefinedValue(env);
+    }
+
+    auto inputParser = [env, context](size_t argc, napi_value *argv) {
+        NAPI_CHECK_ARGS_RETURN_VOID(context, argc >= ARGS_ONE, "invalid arguments",
+            NAPI_ERR_INVALID_PARAM);
+        context->status = NapiParamUtils::GetValueInt32(env, context->target, argv[PARAM0]);
+        NAPI_CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get Target failed",
+            NAPI_ERR_INVALID_PARAM);
+    };
+
+    context->GetCbInfo(env, info, inputParser);
+
+    auto executor = [context]() {
+        CHECK_AND_RETURN_LOG(CheckContextStatus(context), "context object state is error.");
+        auto obj = reinterpret_cast<NapiAudioRenderer*>(context->native);
+        ObjectRefMap objectGuard(obj);
+        auto *napiAudioRenderer = objectGuard.GetPtr();
+        CHECK_AND_RETURN_LOG(CheckAudioRendererStatus(napiAudioRenderer, context),
+            "context object state is error.");
+        if (!NapiAudioEnum::IsLegalRenderTargetType(context->target)) {
+            context->SignError(NAPI_ERR_INVALID_PARAM);
+            return;
+        }
+        RenderTarget target = static_cast<RenderTarget>(context->target);
+        context->intValue = napiAudioRenderer->audioRenderer_->SetTarget(target);
+        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_INJECT_TO_VOICE_COMMUNICATION_CAPTURE_BY_ILLEGAL_STATE) {
+            context->SignError(NAPI_ERR_ILLEGAL_STATE);
+        } else if (context->intValue == ERR_INJECT_TO_VOICE_COMMUNICATION_CAPTURE_BY_ILLEGAL_STREAM) {
+            context->SignError(NAPI_ERR_UNSUPPORTED);
+        } else {
+            context->SignError(NAPI_ERR_SYSTEM);
+        }
+    };
+
+    auto complete = [env](napi_value &output) {
+        output = NapiParamUtils::GetUndefinedValue(env);
+    };
+    return NapiAsyncWork::Enqueue(env, context, "SetTarget", executor, complete);
+}
+
+napi_value NapiAudioRenderer::GetTarget(napi_env env, napi_callback_info info)
+{
+    napi_value result = nullptr;
+    size_t argc = PARAM0;
+    auto *napiAudioRenderer = GetParamWithSync(env, info, argc, nullptr);
+    CHECK_AND_RETURN_RET_LOG(napiAudioRenderer!= nullptr, result, "napiAudioRenderer is nullptr");
+    CHECK_AND_RETURN_RET_LOG(napiAudioRenderer->audioRenderer_ != nullptr, result, "audioRenderer_ is nullptr");
+
+    int32_t target = napiAudioRenderer->audioRenderer_->GetTarget();
+    NapiParamUtils::SetValueInt32(env, target, result);
+    return result;
+}
+
 napi_value NapiAudioRenderer::Start(napi_env env, napi_callback_info info)
 {
     auto context = std::make_shared<AudioRendererAsyncContext>();
diff --git a/frameworks/js/napi/audiorenderer/napi_audio_renderer.h b/frameworks/js/napi/audiorenderer/napi_audio_renderer.h
index beed0e5ec749a545b0e29630c1569f9639105502..d7e0bb751d42c19a51ec30333c367a65f503ad95 100644
--- a/frameworks/js/napi/audiorenderer/napi_audio_renderer.h
+++ b/frameworks/js/napi/audiorenderer/napi_audio_renderer.h
@@ -58,6 +58,7 @@ private:
         int32_t audioRendererRate;
         int32_t rendererFlags;
         int32_t interruptMode;
+        int32_t target;
         bool isTrue;
         uint64_t time;
         size_t bufferLen;
@@ -140,6 +141,8 @@ private:
     static napi_value GetSilentModeAndMixWithOthers(napi_env env, napi_callback_info info);
     static napi_value SetDefaultOutputDevice(napi_env env, napi_callback_info info);
     static napi_value GetCallback(size_t argc, napi_value *argv);
+    static napi_value SetTarget(napi_env env, napi_callback_info info);
+    static napi_value GetTarget(napi_env env, napi_callback_info info);
 
     static napi_status WriteArrayBufferToNative(std::shared_ptr<AudioRendererAsyncContext> context);
 
diff --git a/frameworks/js/napi/common/napi_audio_enum.cpp b/frameworks/js/napi/common/napi_audio_enum.cpp
index a478696166222cbb06b8eb4dbc14bbc6902956b6..d7442033fd189e715836ae7d4e90d76c63ec13de 100644
--- a/frameworks/js/napi/common/napi_audio_enum.cpp
+++ b/frameworks/js/napi/common/napi_audio_enum.cpp
@@ -553,6 +553,11 @@ const std::map<std::string, int32_t> NapiAudioEnum::effectFlagMap = {
     {"CAPTURE_EFFECT_FLAG", CAPTURE_EFFECT_FLAG},
 };
 
+const std::map<std::string, int32_t> NapiAudioEnum::renderTargetMap = {
+    {"PLAYBACK", PLAY_BACK},
+    {"INJECT_TO_VOICE_COMMUNICATION_CAPTURE", INJECT_TO_VOICE_COMMUNICATION_CAPTURE},
+};
+
 NapiAudioEnum::NapiAudioEnum()
     : env_(nullptr) {
 }
@@ -721,6 +726,7 @@ napi_status NapiAudioEnum::InitAudioEnum(napi_env env, napi_value exports)
         DECLARE_NAPI_PROPERTY("OutputDeviceChangeRecommendedAction",
             CreateEnumObject(env, outputDeviceChangeRecommendedActionMap)),
         DECLARE_NAPI_PROPERTY("EffectFlag", CreateEnumObject(env, effectFlagMap)),
+        DECLARE_NAPI_PROPERTY("RenderTarget", CreateEnumObject(env, renderTargetMap)),
     };
     return napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop);
 }
@@ -1184,6 +1190,21 @@ bool NapiAudioEnum::IsLegalCapturerType(int32_t type)
     return result;
 }
 
+bool NapiAudioEnum::IsLegalRenderTargetType(int32_t type)
+{
+    bool result = false;
+    switch (type) {
+        case PLAY_BACK:
+        case INJECT_TO_VOICE_COMMUNICATION_CAPTURE:
+            result = true;
+            break;
+        default:
+            result = false;
+            break;
+    }
+    return result;
+}
+
 bool NapiAudioEnum::IsLegalInputArgumentVolType(int32_t inputType)
 {
     bool result = false;
diff --git a/frameworks/js/napi/common/napi_audio_enum.h b/frameworks/js/napi/common/napi_audio_enum.h
index 3d44de7041b1f655ebde2a465168d86b4a9b9497..27914c3dd75d209997a1c5dffd2b8dfef3605fae 100644
--- a/frameworks/js/napi/common/napi_audio_enum.h
+++ b/frameworks/js/napi/common/napi_audio_enum.h
@@ -123,6 +123,11 @@ public:
         LOOPBACK_MODE_HARDWARE = 0
     };
 
+    enum RenderTarget {
+        PLAY_BACK = 0,
+        INJECT_TO_VOICE_COMMUNICATION_CAPTURE = 1
+    };
+
     static napi_value Init(napi_env env, napi_value exports);
     static bool IsLegalInputArgumentInterruptMode(int32_t interruptMode);
     static bool IsLegalInputArgumentAudioEffectMode(int32_t audioEffectMode);
@@ -159,6 +164,7 @@ public:
     static bool IsLegalInputArgumentAudioLoopbackReverbPreset(int32_t preset);
     static bool IsLegalInputArgumentAudioLoopbackEqualizerPreset(int32_t preset);
     static bool IsLegalInputArgumentSessionScene(int32_t scene);
+    static bool IsLegalRenderTargetType(int32_t type);
 
 private:
     static void Destructor(napi_env env, void *nativeObject, void *finalizeHint);
@@ -305,6 +311,7 @@ private:
     static const std::map<std::string, int32_t> audioSessionStateChangeHintMap;
     static const std::map<std::string, int32_t> outputDeviceChangeRecommendedActionMap;
     static const std::map<std::string, int32_t> effectFlagMap;
+    static const std::map<std::string, int32_t> renderTargetMap;
     static std::unique_ptr<AudioParameters> sAudioParameters_;
 
     std::unique_ptr<AudioParameters> audioParameters_;
diff --git a/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h b/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h
index ba9c38d40287c25bfe4d635053b10b7cd31e6d54..7e730edd712e2dbf5727648342b2d3799a6f7a5f 100644
--- a/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h
+++ b/frameworks/native/audioloopback/test/unittest/include/audio_renderer_mock.h
@@ -124,6 +124,8 @@ public:
     MOCK_METHOD(void, SetInterruptEventCallbackType, (InterruptEventCallbackType callbackType), (override));
     MOCK_METHOD(void, SetAudioHapticsSyncId, (int32_t audioHapticsSyncId), (override));
     MOCK_METHOD(void, ResetFirstFrameState, (), (override));
+    MOCK_METHOD(int32_t, SetTarget, (RenderTarget target), (const, override));
+    MOCK_METHOD(RenderTarget, GetTarget, (), (const, override));
 };
 
 } // namespace AudioStandard
diff --git a/frameworks/native/audiorenderer/include/audio_renderer_private.h b/frameworks/native/audiorenderer/include/audio_renderer_private.h
index 8f697fa87ff23bec9d9523792757ad5f354028a0..e84a71132d801e848ba3e1dc837c54a6086c5209 100644
--- a/frameworks/native/audiorenderer/include/audio_renderer_private.h
+++ b/frameworks/native/audiorenderer/include/audio_renderer_private.h
@@ -106,6 +106,8 @@ public:
     float GetMaxStreamVolume() const override;
     int32_t GetCurrentOutputDevices(AudioDeviceDescriptor &deviceInfo) const override;
     uint32_t GetUnderflowCount() const override;
+    int32_t SetTarget(RenderTarget target) const override;
+    RenderTarget GetTarget() const override;
 
     int32_t RegisterOutputDeviceChangeWithInfoCallback(
         const std::shared_ptr<AudioRendererOutputDeviceChangeCallback> &callback) override;
@@ -163,10 +165,8 @@ public:
     static inline AudioStreamParams ConvertToAudioStreamParams(const AudioRendererParams params)
     {
         AudioStreamParams audioStreamParams;
-
         audioStreamParams.format = params.sampleFormat;
         audioStreamParams.samplingRate = params.sampleRate;
-        audioStreamParams.customSampleRate = params.customSampleRate;
         audioStreamParams.channels = params.channelCount;
         audioStreamParams.encoding = params.encodingType;
         audioStreamParams.channelLayout = params.channelLayout;
@@ -214,6 +214,7 @@ private:
         IAudioStream::SwitchInfo &info);
     bool GenerateNewStream(IAudioStream::StreamClass targetClass, RestoreInfo restoreInfo, RendererState previousState,
         IAudioStream::SwitchInfo &info);
+    bool ContinueAfterConcede(IAudioStream::StreamClass &targetClass, RestoreInfo restoreInfo);
     bool ContinueAfterSplit(RestoreInfo restoreInfo);
     bool InitTargetStream(IAudioStream::SwitchInfo &info, std::shared_ptr<IAudioStream> &audioStream);
     void HandleAudioInterruptWhenServerDied();
diff --git a/frameworks/native/audiorenderer/include/shared_audio_renderer_wrapper.h b/frameworks/native/audiorenderer/include/shared_audio_renderer_wrapper.h
index 67cc3cde0890e86728271323db1a0cef4ad20839..1d78193117b679fe4ad9802601af938406c4df1b 100644
--- a/frameworks/native/audiorenderer/include/shared_audio_renderer_wrapper.h
+++ b/frameworks/native/audiorenderer/include/shared_audio_renderer_wrapper.h
@@ -482,6 +482,16 @@ public:
         return sharedAudioRenderer_->SetInterruptEventCallbackType(callbackType);
     }
 
+    int32_t SetTarget(RenderTarget target) const override
+    {
+        return sharedAudioRenderer_->SetTarget(target);
+    }
+
+    RenderTarget GetTarget() const override
+    {
+        return sharedAudioRenderer_->GetTarget();
+    }
+
     explicit SharedAudioRendererWrapper(std::shared_ptr<AudioRenderer> renderer) : sharedAudioRenderer_(renderer)
     {
     }
diff --git a/frameworks/native/audiorenderer/src/audio_renderer.cpp b/frameworks/native/audiorenderer/src/audio_renderer.cpp
index 2fab083fa8353fa9ab809311f6cba419b9187ecc..15c34c1414d3bb6bd79cd51b3e543ab58984c7bd 100644
--- a/frameworks/native/audiorenderer/src/audio_renderer.cpp
+++ b/frameworks/native/audiorenderer/src/audio_renderer.cpp
@@ -2956,5 +2956,19 @@ int32_t AudioRendererPrivate::HandleCreateFastStreamError(AudioStreamParams &aud
     audioStream_->NotifyRouteUpdate(flag, networkId);
     return ret;
 }
+
+int32_t AudioRendererPrivate::SetTarget(RenderTarget target) const
+{
+    std::shared_ptr<IAudioStream> currentStream = GetInnerStream();
+    CHECK_AND_RETURN_RET_LOG(currentStream != nullptr, ERROR_ILLEGAL_STATE, "audioStream_ is nullptr");
+    return currentStream->SetRenderTarget(target);
+}
+
+RenderTarget AudioRendererPrivate::GetTarget() const
+{
+    std::shared_ptr<IAudioStream> currentStream = GetInnerStream();
+    CHECK_AND_RETURN_RET_LOG(currentStream != nullptr, PLAY_BACK, "audioStream_ is nullptr");
+    return currentStream->GetRenderTarget();
+}
 }  // namespace AudioStandard
 }  // namespace OHOS
diff --git a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp
index 68fad1966e3713b6caa5dab6943582be062bb3d9..97f60fe3c5c8d54002b6d313bf6e83e4015f9c83 100644
--- a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp
+++ b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/renderer_in_client_unit_test.cpp
@@ -101,6 +101,8 @@ public:
 
     virtual int32_t SetOffloadMode(int32_t state, bool isAppBack) override { return 0; } // renderer only
 
+    virtual int32_t SetTarget(int32_t target, int32_t &ret) override { return 0; } // renderer only
+
     virtual int32_t UnsetOffloadMode() override { return 0; } // renderer only
 
     virtual int32_t GetOffloadApproximatelyCacheTime(uint64_t &timestamp, uint64_t &paWriteIndex,
diff --git a/frameworks/native/audiostream/include/i_audio_stream.h b/frameworks/native/audiostream/include/i_audio_stream.h
index 0f7ea1136617e1aa518872742d840f0b1e57d290..25eb4c03f73c8a4b9792881337362ce7a6b86548 100644
--- a/frameworks/native/audiostream/include/i_audio_stream.h
+++ b/frameworks/native/audiostream/include/i_audio_stream.h
@@ -178,6 +178,8 @@ public:
     virtual int32_t SetSpeed(float speed) = 0;
     virtual int32_t SetPitch(float pitch) = 0;
     virtual float GetSpeed() = 0;
+    virtual int32_t SetRenderTarget(RenderTarget target) { return 0; }
+    virtual RenderTarget GetRenderTarget() { return PLAY_BACK; }
 
     virtual void SetUnderflowCount(uint32_t underflowCount) = 0;
     virtual void SetOverflowCount(uint32_t overflowCount) = 0;
diff --git a/interfaces/inner_api/native/audiocommon/include/audio_errors.h b/interfaces/inner_api/native/audiocommon/include/audio_errors.h
index b41f8250d0219746351b43c4a287fdeddc3d608e..32fe3ce2fd8405b03668716b6c1d6e0cc3aa37b8 100644
--- a/interfaces/inner_api/native/audiocommon/include/audio_errors.h
+++ b/interfaces/inner_api/native/audiocommon/include/audio_errors.h
@@ -180,6 +180,12 @@ const int32_t ERR_PRO_STREAM_NOT_SUPPORTED = BASE_AUDIO_ERR_OFFSET - 39;
 /** failed to set volume because isVolumeControlDisabled is true */
 const int32_t ERR_SET_VOL_FAILED_BY_VOLUME_CONTROL_DISABLED = BASE_AUDIO_ERR_OFFSET - 40;
 
+/** failed to inject because state is not illegal */
+const int32_t ERR_INJECT_TO_VOICE_COMMUNICATION_CAPTURE_BY_ILLEGAL_STATE = BASE_AUDIO_ERR_OFFSET - 41;
+
+/** failed to inject because stream is not normal */
+const int32_t ERR_INJECT_TO_VOICE_COMMUNICATION_CAPTURE_BY_ILLEGAL_STREAM = BASE_AUDIO_ERR_OFFSET - 42;
+
 /** Unknown error */
 const int32_t  ERR_UNKNOWN = BASE_AUDIO_ERR_OFFSET - 200;
 }  // namespace AudioStandard
diff --git a/interfaces/inner_api/native/audiocommon/include/audio_info.h b/interfaces/inner_api/native/audiocommon/include/audio_info.h
index 6ab761a85cf820cb3eec1fba3f6ad20ca605429a..ee1cfc463bc4342db56b0fd73522150f30080675 100644
--- a/interfaces/inner_api/native/audiocommon/include/audio_info.h
+++ b/interfaces/inner_api/native/audiocommon/include/audio_info.h
@@ -1958,6 +1958,14 @@ enum XperfEventId : int32_t {
     XPERF_EVENT_MAX = 4,
 };
 
+/**
+ * Enumerates the audio playback target
+ */
+enum RenderTarget {
+    PLAY_BACK = 0,
+    INJECT_TO_VOICE_COMMUNICATION_CAPTURE = 1
+};
+
 struct FetchDeviceInfo : public Parcelable {
     StreamUsage streamUsage = STREAM_USAGE_UNKNOWN;
     int32_t clientUID = -1;
diff --git a/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h b/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h
index 0d1b021e47d5e574094130e72a706cc161222814..f89f22b158fb385873c3a8de7b90d3df7f81361f 100644
--- a/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h
+++ b/interfaces/inner_api/native/audiorenderer/include/audio_renderer.h
@@ -587,7 +587,7 @@ public:
      * @since 8
      */
     virtual AudioRendererRate GetRenderRate() const = 0;
-
+    
     /**
      * @brief Set the render sampling rate
      *
@@ -1120,6 +1120,22 @@ public:
      */
     static bool CheckSupportedSamplingRates(uint32_t rates);
 
+    /**
+     * @brief Sef the render target
+     * @param target The target at which the stream needs to be rendered.
+     * @return Returns {@link SUCCESS} if render target is successfully set; returns an error code
+     * defined in {@link audio_errors.h} otherwise.
+     * @since 22
+     */
+    virtual int32_t SetTarget(RenderTarget target) const { return 0; };
+
+    /**
+     * @brief Obtains the current render target
+     * @return Returns current render target
+     * @since 22
+     */
+    virtual RenderTarget GetTarget() const { return PLAY_BACK; }
+
 private:
     static void SendRendererCreateError(const StreamUsage &sreamUsage,
         const int32_t &errorCode);
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..c3b418801c66d2479eba78db085d9beae6f70544 100644
--- a/services/audio_service/client/include/renderer_in_client_private.h
+++ b/services/audio_service/client/include/renderer_in_client_private.h
@@ -221,6 +221,8 @@ public:
     void NotifyRouteUpdate(uint32_t routeFlag, const std::string &networkId) override;
     bool GetStopFlag() const override;
     void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override;
+    int32_t SetRenderTarget(RenderTarget renderTarget) override;
+    RenderTarget GetRenderTarget() override;
 
 private:
     void RegisterTracker(const std::shared_ptr<AudioClientTracker> &proxyObj);
@@ -314,7 +316,7 @@ private:
     bool streamTrackerRegistered_ = false;
 
     std::atomic<bool> needSetThreadPriority_ = true;
-
+    RenderTarget renderTarget_ = PLAY_BACK;
     AudioStreamParams curStreamParams_ = {0}; // in plan next: replace it with AudioRendererParams
     AudioStreamParams streamParams_ = {0};
 
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..8d5ffd2f601f29d9e21bd7464cdb940df962f060 100644
--- a/services/audio_service/client/src/renderer_in_client_public.cpp
+++ b/services/audio_service/client/src/renderer_in_client_public.cpp
@@ -569,6 +569,24 @@ AudioRendererRate RendererInClientInner::GetRenderRate()
     return rendererRate_;
 }
 
+
+int32_t RendererInClientInner::SetRenderTarget(RenderTarget renderTarget)
+{
+    CHECK_AND_RETURN_RET_LOG(renderTarget_ != renderTarget, SUCCESS, "Set same renderTarget");
+    CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, ERR_ILLEGAL_STATE, "ipcStream is not inited!");
+    renderTarget_ = renderTarget;
+    int32_t ret = 0;
+    AUDIO_INFO_LOG("Set render target: %{public}d", renderTarget);
+    ipcStream_->SetTarget(renderTarget, ret);
+    return ret;
+}
+
+RenderTarget RendererInClientInner::GetRenderTarget()
+{
+    AUDIO_INFO_LOG("Get RenderRate %{public}d", renderTarget_);
+    return renderTarget_;
+}
+
 int32_t RendererInClientInner::SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback)
 {
     if (callback == nullptr) {
diff --git a/services/audio_service/idl/IIpcStream.idl b/services/audio_service/idl/IIpcStream.idl
index c45da9db890d8e4c8a021b8d96515aa867f0a40b..319760fdb064386749485a2944c53ddf1ba7d916 100644
--- a/services/audio_service/idl/IIpcStream.idl
+++ b/services/audio_service/idl/IIpcStream.idl
@@ -65,4 +65,5 @@ interface IIpcStream {
     void ResolveBufferBaseAndGetServerSpanSize([out] sharedptr<OHAudioBufferBase> buffer,
         [out] unsigned int spanSizeInFrame, [out] unsigned long engineTotalSizeInFrame);
     void SetAudioHapticsSyncId([in] int audioHapticsSyncId);
+    void SetTarget([in] int target, [out] int ret); //SetRenderTarget
 }
\ No newline at end of file
diff --git a/services/audio_service/server/include/ipc_stream_in_server.h b/services/audio_service/server/include/ipc_stream_in_server.h
index 4f6993171b41c5532d033d703f66100e5b3c1284..c9887eb3a56d6f2d473f3e47bdd8e1c7a1517758 100644
--- a/services/audio_service/server/include/ipc_stream_in_server.h
+++ b/services/audio_service/server/include/ipc_stream_in_server.h
@@ -133,7 +133,8 @@ public:
         uint32_t &spanSizeInFrame, uint64_t &engineTotalSizeInFrame) override;
     
     int32_t SetAudioHapticsSyncId(int32_t audioHapticsSyncId) override;
-
+    
+    int32_t SetTarget(int32_t target, int32_t &ret) override;
     // for inner-capturer
     std::shared_ptr<RendererInServer> GetRenderer();
     std::shared_ptr<CapturerInServer> GetCapturer();
diff --git a/services/audio_service/server/include/renderer_in_server.h b/services/audio_service/server/include/renderer_in_server.h
index 5208dc16983e7f5fb733abd5ecf75927df8f9a92..f3b0b4f522ee49409501820b3437b1cfea733b22 100644
--- a/services/audio_service/server/include/renderer_in_server.h
+++ b/services/audio_service/server/include/renderer_in_server.h
@@ -83,6 +83,7 @@ public:
     int32_t GetSpeedPosition(uint64_t &framePos, uint64_t &timestamp, uint64_t &latency, int32_t base);
     int32_t GetLatency(uint64_t &latency);
     int32_t SetRate(int32_t rate);
+    int32_t SetTarget(int32_t target, int32_t &ret);
     int32_t SetLowPowerVolume(float volume);
     int32_t GetLowPowerVolume(float &volume);
     int32_t SetAudioEffectMode(int32_t effectMode);
diff --git a/services/audio_service/server/src/ipc_stream_in_server.cpp b/services/audio_service/server/src/ipc_stream_in_server.cpp
index 4cf945ae8d323e548449dbf37b50a9a25a3bc991..0b07d8e9c1c02a22a8cb266f673401e5456486e0 100644
--- a/services/audio_service/server/src/ipc_stream_in_server.cpp
+++ b/services/audio_service/server/src/ipc_stream_in_server.cpp
@@ -337,6 +337,16 @@ int32_t IpcStreamInServer::GetRate(int32_t &rate)
     return ERR_OPERATION_FAILED;
 }
 
+ int32_t IpcStreamInServer::SetTarget(int32_t target, int32_t &ret)
+{
+    if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
+        rendererInServer_->SetTarget(target, ret);
+        return ret;
+    }
+    AUDIO_ERR_LOG("SetTarget failed, invalid mode: %{public}d", static_cast<int32_t>(mode_));
+    return ERR_OPERATION_FAILED;
+}
+
 int32_t IpcStreamInServer::SetLowPowerVolume(float volume)
 {
     if (mode_ == AUDIO_MODE_PLAYBACK && rendererInServer_ != nullptr) {
diff --git a/services/audio_service/server/src/renderer_in_server.cpp b/services/audio_service/server/src/renderer_in_server.cpp
index e49341db395011d4a91eee0ef966602b5d0545ed..896ad7d7833b864cd6fe836d35d458b332e03a2a 100644
--- a/services/audio_service/server/src/renderer_in_server.cpp
+++ b/services/audio_service/server/src/renderer_in_server.cpp
@@ -2365,6 +2365,12 @@ void RendererInServer::InitDupBuffer(int32_t innerCapId)
         innerCapId, streamIndex_);
 }
 
+int32_t RendererInServer::SetTarget(int32_t target, int32_t &ret)
+{
+    ret = SUCCESS;
+    return SUCCESS;
+}
+
 int32_t RendererInServer::InitSoftLink(int32_t innerCapId)
 {
     std::lock_guard<std::mutex> lock(softLinkMutex_);
diff --git a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp
index b68a61ad2028e622b3cfb898649e75cc9183af89..f06af94d33ba91bb39a8906f0638bd3540d92bc1 100644
--- a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp
+++ b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp
@@ -157,6 +157,8 @@ public:
     virtual int32_t GetPrivacyType(int32_t &privacyType) override { return 0; } // renderer only
 
     virtual int32_t SetOffloadMode(int32_t state, bool isAppBack) override { return 0; } // renderer only
+    
+    virtual int32_t SetTarget(int32_t target, int32_t &ret) override { return 0; } // renderer only
 
     virtual int32_t UnsetOffloadMode() override { return 0; } // renderer only