diff --git a/audiohandler/BUILD.gn b/audiohandler/BUILD.gn
index 683a1910ac07d37c548302c19a870eb210c7d0e9..0a49359d922846baa75a4683b0b44e94a91eada1 100644
--- a/audiohandler/BUILD.gn
+++ b/audiohandler/BUILD.gn
@@ -38,6 +38,7 @@ ohos_shared_library("distributed_audio_handler") {
     "audio_framework:audio_capturer",
     "audio_framework:audio_client",
     "audio_framework:audio_renderer",
+    "av_codec:av_codec_client",
     "cJSON:cjson",
     "c_utils:utils",
     "distributed_hardware_fwk:distributedhardwareutils",
diff --git a/audiohandler/include/daudio_handler.h b/audiohandler/include/daudio_handler.h
index a7933d0d6c3a4d6333f73102b94a17fd716a4f92..e4180f8bd2feaad9831ac062ea17537ced135843 100644
--- a/audiohandler/include/daudio_handler.h
+++ b/audiohandler/include/daudio_handler.h
@@ -54,6 +54,8 @@ private:
     bool AddItemsToObject(DHItem &dhItem, cJSON *infoJson, const int32_t &dhId);
     bool AddParamsToJson(DHItem &dhItem, cJSON* infoJson, const std::string &subtype, const AudioInfo &infos);
     std::vector<DHItem> RealQuery(const std::string &dataType);
+    bool IsMimeSupported(const std::string &coder);
+    void AddToVec(std::vector<std::string> &container, const std::string &value);
 private:
     AudioInfo spkInfos_;
     AudioInfo micInfos_;
diff --git a/audiohandler/src/daudio_handler.cpp b/audiohandler/src/daudio_handler.cpp
index c1f270b2fb3f32d313a831d1d5a3f65f13fc87da..d1d12b04a7524c3b045d9fd86d4354be1e8220fe 100644
--- a/audiohandler/src/daudio_handler.cpp
+++ b/audiohandler/src/daudio_handler.cpp
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "audio_system_manager.h"
+#include "avcodec_list.h"
 #include "string_ex.h"
 
 #include "daudio_constants.h"
@@ -172,6 +173,31 @@ std::vector<DHItem> DAudioHandler::ablityForDump()
     return ablityForDumpVec_;
 }
 
+bool DAudioHandler::IsMimeSupported(const std::string &coder)
+{
+    DHLOGD("Craete avCodecList start.");
+    std::shared_ptr<MediaAVCodec::AVCodecList> avCodecList = MediaAVCodec::AVCodecListFactory::CreateAVCodecList();
+    if (avCodecList == nullptr) {
+        DHLOGE("Create avCodecList failed.");
+        return false;
+    }
+    MediaAVCodec::CapabilityData *capData = avCodecList->GetCapability(coder, true,
+        MediaAVCodec::AVCodecCategory::AVCODEC_NONE);
+    if (capData == nullptr) {
+        DHLOGI("%{public}s is not supported.", coder.c_str());
+        return false;
+    }
+    return true;
+}
+
+void DAudioHandler::AddToVec(std::vector<std::string> &container, const std::string &value)
+{
+    auto it = std::find(container.begin(), container.end(), value);
+    if (it == container.end()) {
+        container.push_back(value);
+    }
+}
+
 int32_t DAudioHandler::QueryAudioInfo()
 {
     DHLOGD("Start to query codec information.");
@@ -181,9 +207,14 @@ int32_t DAudioHandler::QueryAudioInfo()
     spkInfos_.sampleRates = OHOS::AudioStandard::AudioRenderer::GetSupportedSamplingRates();
     spkInfos_.formats = OHOS::AudioStandard::AudioRenderer::GetSupportedFormats();
     spkInfos_.channels = OHOS::AudioStandard::AudioRenderer::GetSupportedChannels();
-    supportedStream_.push_back(MUSIC);
-    codec_.push_back(AAC);
-    codec_.push_back(PCM);
+    AddToVec(supportedStream_, MUSIC);
+    AddToVec(codec_, PCM);
+    if (IsMimeSupported(std::string(MediaAVCodec::CodecMimeType::AUDIO_AAC))) {
+        AddToVec(codec_, AAC);
+    }
+    if (IsMimeSupported(std::string(MediaAVCodec::CodecMimeType::AUDIO_OPUS))) {
+        AddToVec(codec_, OPUS);
+    }
     return DH_SUCCESS;
 }
 
diff --git a/audiohandler/test/unittest/src/daudio_handler_test.cpp b/audiohandler/test/unittest/src/daudio_handler_test.cpp
index 53fa86d2b0e6a6a3c3cc5b0b436b831d4d27acbd..bfa26a8cf07c1bbf51dcbca41da33cb66ea06287 100644
--- a/audiohandler/test/unittest/src/daudio_handler_test.cpp
+++ b/audiohandler/test/unittest/src/daudio_handler_test.cpp
@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <vector>
 
 using namespace testing::ext;
 
@@ -65,5 +66,32 @@ HWTEST_F(DAudioHandlerTest, Query_001, TestSize.Level1)
     int32_t actual = DAudioHandler::GetInstance().Query().size();
     EXPECT_LE(DH_SUCCESS, actual);
 }
+
+/**
+ * @tc.name: IsMimeSupported_001
+ * @tc.desc: Verify the IsMimeSupported function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioHandlerTest, IsMimeSupported_001, TestSize.Level1)
+{
+    std::string coder = "AAAA";
+    bool isSupport = DAudioHandler::GetInstance().IsMimeSupported(coder);
+    EXPECT_EQ(false, isSupport);
+}
+
+/**
+ * @tc.name: AddToVec_001
+ * @tc.desc: Verify the AddToVec function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioHandlerTest, AddToVec_001, TestSize.Level1)
+{
+    std::vector<std::string> container;
+    std::string coder = "AAAA";
+    DAudioHandler::GetInstance().AddToVec(container, coder);
+    EXPECT_EQ(container.size(), 1);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/bundle.json b/bundle.json
index ca318f31d3f37a777bf3826985c2b7eb2fcbb8b9..f07fe62c313fe82312935ca48b5a661a789d6fdf 100755
--- a/bundle.json
+++ b/bundle.json
@@ -31,6 +31,7 @@
                 "access_token",
                 "accessibility",
                 "audio_framework",
+                "av_codec",
                 "cJSON",
                 "c_utils",
                 "device_security_level",
diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h
index 4b198e66ccf5f55c26263827e986b9d41e2fbdf5..48f1de952d3f63768d19849e5488629f6f46a524 100644
--- a/common/include/daudio_constants.h
+++ b/common/include/daudio_constants.h
@@ -158,6 +158,7 @@ constexpr const char *CHANNELMASKS = "ChannelMasks";
 constexpr const char *FORMATS = "Formats";
 const std::string MUSIC = "Music";
 const std::string PCM = "PCM";
+const std::string OPUS = "OPUS";
 const std::string AAC = "AAC";
 const std::string MIC = "mic";
 const std::string SPEAKER = "speaker";
diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp
index 0b2f2441f2f419e9a2d6b674e0662f2e83e5aebe..ffb487ba16ff3f74f37e64b63ac30bbcfcd6ef3d 100644
--- a/common/src/daudio_util.cpp
+++ b/common/src/daudio_util.cpp
@@ -67,6 +67,7 @@ std::map<std::string, JsonTypeCheckFunc> typeCheckMap = {
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_STREAM_USAGE, &DistributedHardware::IsInt32),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_DATATYPE, &DistributedHardware::IsString),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_CODEC_TYPE, &DistributedHardware::IsInt32),
+    std::map<std::string, JsonTypeCheckFunc>::value_type(CODEC, &DistributedHardware::IsString),
 };
 
 std::map<int32_t, std::string> eventNameMap = {
diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
index 0562f506881ec87a44c2aeae346bb5058e164a07..97fd01f83fddfce1bce102644c6d4e1e05e4f015 100644
--- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
@@ -292,7 +292,6 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args)
     ret = micClient->StartCapture();
     CHECK_AND_FREE_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, jParam,
         "Start capture failed, ret: %{public}d.", ret);
-    PullUpPage();
     isMicInUse_.store(true);
     cJSON_Delete(jParam);
     return ret;
@@ -315,13 +314,6 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args)
     ret = micClient->Release();
     CHECK_AND_LOG(ret != DH_SUCCESS, "Release mic client failed, ret: %{public}d.", ret);
     micClientMap_.erase(dhId);
-    if (isPageStatus_.load() && ipcSinkCallback_ != nullptr) {
-        bool isSensitive = false;
-        bool isSameAccount = false;
-        ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, SUBTYPE, devId_,
-            isSensitive, isSameAccount);
-        isPageStatus_.store(false);
-    }
     DHLOGI("Close mic device task excute success.");
     return DH_SUCCESS;
 }
diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
index 79a0f2c7358a74de135fb07439e9d8b1618f8921..1a459634256fb01b0232535b013e1db580ea2966 100644
--- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
@@ -231,11 +231,6 @@ int32_t DAudioSinkManager::InitAudioDevice(std::shared_ptr<DAudioSinkDev> dev, c
     if (isSpkOrMic) {
         ret = dev->InitAVTransEngines(ChannelState::SPK_CONTROL_OPENED, rcvProviderPtr_);
     } else {
-        ret = VerifySecurityLevel(devId);
-        if (ret != DH_SUCCESS) {
-            DHLOGE("Verify security level failed.");
-            return ERR_DH_AUDIO_FAILED;
-        }
         dev->SetDevLevelStatus(true);
         ret = dev->InitAVTransEngines(ChannelState::MIC_CONTROL_OPENED, sendProviderPtr_);
     }
diff --git a/services/audiomanager/managersource/include/daudio_echo_cannel_manager.h b/services/audiomanager/managersource/include/daudio_echo_cannel_manager.h
index 4b168f763b8cb24d77d7390176b30dfc1ac93e23..8d3461bdabbd59f154f755de3aaa5e055ae158f3 100644
--- a/services/audiomanager/managersource/include/daudio_echo_cannel_manager.h
+++ b/services/audiomanager/managersource/include/daudio_echo_cannel_manager.h
@@ -49,6 +49,8 @@ private:
     void OnReadData(size_t length) override;
     void AecProcessData();
     void CircuitStart();
+    void CircuitStop();
+    void CircuitRelease();
     int32_t ProcessMicData(const std::shared_ptr<AudioData> &pipeInData,
         std::shared_ptr<AudioData> &micOutData);
     
@@ -75,7 +77,11 @@ private:
     std::thread aecProcessThread_;
     static constexpr const char* AECTHREADNAME = "AecProcessThread";
     std::atomic<bool> isCircuitStartRunning_ = false;
+    std::atomic<bool> isCircuitStoped_ = false;
+    std::atomic<bool> isCircuitReleased_ = false;
     std::thread circuitStartThread_;
+    std::thread circuitStopThread_;
+    std::thread circuitReleaseThread_;
 
     std::shared_ptr<IAudioDataTransCallback> devCallback_;
     void *aecHandler_ = nullptr;
diff --git a/services/audiomanager/managersource/include/dmic_dev.h b/services/audiomanager/managersource/include/dmic_dev.h
index 42ec716118d3ee774bdae1d5ecd3e86b5f9f579b..46a422613309376ff69f594d7e6d05568404eefd 100644
--- a/services/audiomanager/managersource/include/dmic_dev.h
+++ b/services/audiomanager/managersource/include/dmic_dev.h
@@ -96,6 +96,9 @@ private:
     void FillJitterQueue();
     void ReadFromRingbuffer();
     void SendToProcess(const std::shared_ptr<AudioData> &audioData);
+    void GetCodecCaps(const std::string &capability);
+    void AddToVec(std::vector<AudioCodecType> &container, const AudioCodecType value);
+    bool IsMimeSupported(const AudioCodecType coder);
 
 private:
     static constexpr uint8_t CHANNEL_WAIT_SECONDS = 5;
@@ -132,7 +135,6 @@ private:
     AudioParam param_;
 
     std::atomic<bool> isExistedEmpty_ = false;
-    std::atomic<bool> isNeedCodec_ = true;
     size_t dataQueSize_ = 0;
     sptr<Ashmem> ashmem_ = nullptr;
     std::atomic<bool> isEnqueueRunning_ = false;
@@ -160,6 +162,7 @@ private:
     std::thread ringbufferThread_;
     std::atomic<bool> isRingbufferOn_ = false;
     std::mutex ringbufferMutex_;
+    std::vector<AudioCodecType> codec_;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/managersource/include/dspeaker_dev.h b/services/audiomanager/managersource/include/dspeaker_dev.h
index 42c549e41ee575ec8405af4c5cdd31c15679ebe5..68d2eaeaa008aaa3523d61b32713e48d6c8f96cf 100644
--- a/services/audiomanager/managersource/include/dspeaker_dev.h
+++ b/services/audiomanager/managersource/include/dspeaker_dev.h
@@ -87,6 +87,9 @@ public:
 
 private:
     void EnqueueThread();
+    void GetCodecCaps(const std::string &capability);
+    void AddToVec(std::vector<AudioCodecType> &container, const AudioCodecType value);
+    bool IsMimeSupported(const AudioCodecType coder);
 
 private:
     static constexpr const char* ENQUEUE_THREAD = "spkEnqueueTh";
@@ -110,7 +113,6 @@ private:
 
     sptr<Ashmem> ashmem_ = nullptr;
     std::atomic<bool> isEnqueueRunning_ = false;
-    std::atomic<bool> isNeedCodec_ = true;
     int32_t ashmemLength_ = -1;
     int32_t lengthPerTrans_ = -1;
     int32_t readIndex_ = -1;
@@ -124,6 +126,7 @@ private:
     int32_t dhId_ = -1;
     FILE *dumpFileCommn_ = nullptr;
     FILE *dumpFileFast_ = nullptr;
+    std::vector<AudioCodecType> codec_;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp b/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp
index 9c5161e0706f4133de22bfb17276f8609d8e780d..f264d5d6cc72be420effb752ae94ba53f569c2fb 100644
--- a/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp
+++ b/services/audiomanager/managersource/src/daudio_echo_cannel_manager.cpp
@@ -96,33 +96,54 @@ int32_t DAudioEchoCannelManager::Start()
 int32_t DAudioEchoCannelManager::Stop()
 {
     DHLOGI("Stop EchoCannel.");
+    if (!isCircuitStoped.load()) {
+        isCircuitStoped_.store(true);
+        circuitStopThread_ = std::thread([this]() { this->CircuitStop(); });
+        circuitStopThread_.detach();
+        DHLOGI("circuitStopThread_ is on.");
+    }
+    return DH_SUCCESS;
+}
+
+void DAudioEchoCannelManager::CircuitStop()
+{
     isStarted.store(false);
     int32_t ret = StopAecProcessor();
-    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Stop Aec Processor error. ret: %{public}d.", ret);
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Stop Aec Processor error. ret: %{public}d.", ret);
     ret = AudioCaptureStop();
-    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Stop Get Reference error. ret: %{public}d.", ret);
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Stop AudioCapture error. ret: %{public}d.", ret);
     DHLOGI("Stop EchoCannel success.");
-    return DH_SUCCESS;
 }
 
 int32_t DAudioEchoCannelManager::Release()
 {
     DHLOGI("Release EchoCannel.");
-    int32_t ret = AudioCaptureRelease();
-    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Release Get Reference error. ret: %{public}d.", ret);
-
-    ret = ReleaseAecProcessor();
-    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ret, "Release Aec Processor error. ret: %{public}d.", ret);
-    UnLoadAecProcessor();
+    if (!isCircuitRelease_.load()) {
+        isCircuitRelease_.store(true);
+        circuitReleaseThread_ = std::thread([this]() { this->CircuitRelease(); });
+        circuitReleaseThread_.detach();
+        DHLOGI("circuitReleaseThread_ is on.");
+    }
+    isStarted.store(false);
+    isCircuitStartRunning_.store(false);
+    isCircuitStoped_.store(false);
+    isCircuitReleased.store(false);
     DumpFileUtil::CloseDumpFile(&dumpFileRef_);
     DumpFileUtil::CloseDumpFile(&dumpFileRec_);
     DumpFileUtil::CloseDumpFile(&dumpFileAft_);
     DumpFileUtil::CloseDumpFile(&dumpFileCir_);
-    isStarted.store(false);
-    isCircuitStartRunning_.store(false);
     return DH_SUCCESS;
 }
 
+void DAudioEchoCannelManager::CircuitRelease()
+{
+    int32_t ret = AudioCaptureRelease();
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Release AudioCapture error. ret: %{public}d.", ret);
+    ret = ReleaseAecProcessor();
+    CHECK_AND_RETURN_LOG(ret != DH_SUCCESS, "Release Aec Processor error. ret: %{public}d.", ret);
+    UnLoadAecProcessor();
+}
+
 int32_t DAudioEchoCannelManager::OnMicDataReceived(const std::shared_ptr<AudioData> &pipeInData)
 {
     DHLOGD("GetMicDataBeforeAec.");
diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp
index 12df0aa2b4ac1a195699e4f67a03974fae42ce0f..fada4e8b119c65c414ae0e16c6eaa831114ab68f 100644
--- a/services/audiomanager/managersource/src/dmic_dev.cpp
+++ b/services/audiomanager/managersource/src/dmic_dev.cpp
@@ -175,14 +175,30 @@ int32_t DMicDev::EnableDevice(const int32_t dhId, const std::string &capability)
         return ret;
     }
     dhId_ = dhId;
-    auto pos = capability.find(SUB_PROTOCOLVER);
+    GetCodecCaps(capability);
+    return DH_SUCCESS;
+}
+
+void DMicDev::AddToVec(std::vector<AudioCodecType> &container, const AudioCodecType value)
+{
+    auto it = std::find(container.begin(), container.end(), value);
+    if (it == container.end()) {
+        container.push_back(value);
+    }
+}
+
+void DMicDev::GetCodecCaps(const std::string &capability)
+{
+    auto pos = capability.find(AAC);
     if (pos != std::string::npos) {
-        DHLOGD("ProtocolVer : 2.0");
-    } else {
-        isNeedCodec_.store(false);
-        DHLOGD("ProtocolVer : 1.0");
+        AddToVec(codec_, AudioCodecType::AUDIO_CODEC_AAC_EN);
+        DHLOGI("Daudio codec cap: AAC");
+    }
+    pos = capability.find(OPUS);
+    if (pos != std::string::npos) {
+        AddToVec(codec_, AudioCodecType::AUDIO_CODEC_OPUS);
+        DHLOGI("Daudio codec cap: OPUS");
     }
-    return DH_SUCCESS;
 }
 
 int32_t DMicDev::DisableDevice(const int32_t dhId)
@@ -198,6 +214,16 @@ int32_t DMicDev::DisableDevice(const int32_t dhId)
     return DH_SUCCESS;
 }
 
+bool DMicDev::IsMimeSupported(const AudioCodecType coder)
+{
+    auto iter = std::find(codec_.begin(), codec_.end(), coder);
+    if (iter == codec_.end()) {
+        DHLOGI("devices have no cap: %{public}d", static_cast<int>(coder));
+        return false;
+    }
+    return true;
+}
+
 int32_t DMicDev::CreateStream(const int32_t streamId)
 {
     DHLOGI("Open stream of mic device streamId: %{public}d.", streamId);
@@ -269,11 +295,6 @@ int32_t DMicDev::SetParameters(const int32_t streamId, const AudioParamHDF &para
     param_.comParam.sampleRate = paramHDF_.sampleRate;
     param_.comParam.channelMask = paramHDF_.channelMask;
     param_.comParam.bitFormat = paramHDF_.bitFormat;
-    param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC;
-    if (isNeedCodec_.load()) {
-        param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN;
-    }
-    DHLOGD("isNeedCodec_ : %{public}d.", isNeedCodec_.load());
     param_.comParam.frameSize = paramHDF_.frameSize;
     if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION) {
         param_.captureOpts.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
@@ -285,6 +306,14 @@ int32_t DMicDev::SetParameters(const int32_t streamId, const AudioParamHDF &para
         lowLatencyHalfSize_ = LOW_LATENCY_JITTER_TIME_MS / paramHDF_.period;
         lowLatencyMaxfSize_ = LOW_LATENCY_JITTER_MAX_TIME_MS / paramHDF_.period;
     }
+    param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC;
+    if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION &&
+        IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS)) {
+        param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_OPUS;
+    } else if (IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN)) {
+        param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN;
+    }
+    DHLOGI("codecType : %{public}d.", static_cast<int>(param_.comParam.codecType));
     return DH_SUCCESS;
 }
 
diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp
index b1ef6becd9baf443002ef7d81a1517b56b49f2c9..18ee517273e9ff07888bfdbe26f2ec7c31205319 100644
--- a/services/audiomanager/managersource/src/dspeaker_dev.cpp
+++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp
@@ -48,14 +48,30 @@ int32_t DSpeakerDev::EnableDevice(const int32_t dhId, const std::string &capabil
         return ret;
     }
     dhId_ = dhId;
-    auto pos = capability.find(SUB_PROTOCOLVER);
+    GetCodecCaps(capability);
+    return DH_SUCCESS;
+}
+
+void DSpeakerDev::AddToVec(std::vector<AudioCodecType> &container, const AudioCodecType value)
+{
+    auto it = std::find(container.begin(), container.end(), value);
+    if (it == container.end()) {
+        container.push_back(value);
+    }
+}
+
+void DSpeakerDev::GetCodecCaps(const std::string &capability)
+{
+    auto pos = capability.find(AAC);
     if (pos != std::string::npos) {
-        DHLOGD("ProtocolVer : 2.0");
-    } else {
-        isNeedCodec_.store(false);
-        DHLOGD("ProtocolVer : 1.0");
+        AddToVec(codec_, AudioCodecType::AUDIO_CODEC_AAC_EN);
+        DHLOGI("Daudio codec cap: AAC");
+    }
+    pos = capability.find(OPUS);
+    if (pos != std::string::npos) {
+        AddToVec(codec_, AudioCodecType::AUDIO_CODEC_OPUS);
+        DHLOGI("Daudio codec cap: OPUS");
     }
-    return DH_SUCCESS;
 }
 
 int32_t DSpeakerDev::DisableDevice(const int32_t dhId)
@@ -71,6 +87,16 @@ int32_t DSpeakerDev::DisableDevice(const int32_t dhId)
     return DH_SUCCESS;
 }
 
+bool DSpeakerDev::IsMimeSupported(const AudioCodecType coder)
+{
+    auto iter = std::find(codec_.begin(), codec_.end(), coder);
+    if (iter == codec_.end()) {
+        DHLOGI("devices have no cap: %{public}d", static_cast<int>(coder));
+        return false;
+    }
+    return true;
+}
+
 int32_t DSpeakerDev::InitReceiverEngine(IAVEngineProvider *providerPtr)
 {
     DHLOGI("InitReceiverEngine enter.");
@@ -216,10 +242,13 @@ int32_t DSpeakerDev::SetParameters(const int32_t streamId, const AudioParamHDF &
     param_.renderOpts.contentType = CONTENT_TYPE_MUSIC;
     param_.renderOpts.renderFlags = paramHDF_.renderFlags;
     param_.renderOpts.streamUsage = paramHDF_.streamUsage;
-    if (isNeedCodec_.load()) {
+    if (paramHDF_.streamUsage == StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION &&
+        IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS)) {
+        param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_OPUS;
+    } else if (IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN)) {
         param_.comParam.codecType = AudioCodecType::AUDIO_CODEC_AAC_EN;
     }
-    DHLOGD("isNeedCodec_: %{public}d", isNeedCodec_.load());
+    DHLOGI("codecType: %{public}d", static_cast<int>(param_.comParam.codecType));
     return DH_SUCCESS;
 }
 
diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp
index 7f2c81f1dbcb4f51c8ecd2f5433de74801e99df5..18f804d39168ea2a81422592806ee129ddf4766d 100644
--- a/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp
+++ b/services/audiomanager/test/unittest/sourcedevice/src/dmic_dev_test.cpp
@@ -153,6 +153,10 @@ HWTEST_F(DMicDevTest, SetParameters_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
     param.period = 20;
     EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
+    mic_->GetCodecCaps(AAC);
+    mic_->GetCodecCaps(OPUS);
+    param.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
+    EXPECT_EQ(DH_SUCCESS, mic_->SetParameters(streamId_, param));
 }
 
 /**
@@ -414,5 +418,55 @@ HWTEST_F(DMicDevTest, SendMessage_001, TestSize.Level1)
     mic_->InitCtrlTrans();
     EXPECT_EQ(DH_SUCCESS, mic_->SendMessage(OPEN_MIC, content, dstDevId));
 }
+
+/**
+ * @tc.name: AddToVec001
+ * @tc.desc: Verify AddToVec function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DMicDevTest, AddToVec001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container;
+    mic_->AddToVec(container, AudioCodecType::AUDIO_CODEC_AAC);
+    EXPECT_EQ(1, container.size());
+}
+
+/**
+ * @tc.name: GetCodecCaps001
+ * @tc.desc: Verify GetCodecCaps function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DMicDevTest, GetCodecCaps001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container = mic_->codec_;
+    mic_->codec_.clear();
+    mic_->GetCodecCaps(AAC);
+    auto num = mic_->codec_.size();
+    EXPECT_EQ(1, num);
+    mic_->GetCodecCaps(OPUS);
+    num = mic_->codec_.size();
+    mic_->codec_ = container;
+    EXPECT_EQ(2, num);
+}
+
+/**
+ * @tc.name: IsMimeSupported001
+ * @tc.desc: Verify IsMimeSupported function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DMicDevTest, IsMimeSupported001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container = mic_->codec_;
+    mic_->codec_.clear();
+    mic_->GetCodecCaps(AAC);
+    bool ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN);
+    EXPECT_EQ(ret, true);
+    ret = mic_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS);
+    mic_->codec_ = container;
+    EXPECT_EQ(ret, false);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp
index a94f16ad4b6849db02c345788f1ac979c1ebfb24..388013661deafb7deeb599c7bc586a2c44dd99a8 100644
--- a/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp
+++ b/services/audiomanager/test/unittest/sourcedevice/src/dspeaker_dev_test.cpp
@@ -154,6 +154,33 @@ HWTEST_F(DSpeakerDevTest, SetParameters_001, TestSize.Level1)
     spk_->GetAudioParam();
 }
 
+/**
+ * @tc.name: SetParameters_002
+ * @tc.desc: Verify SetParameters and GetAudioParam function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DSpeakerDevTest, SetParameters_002, TestSize.Level1)
+{
+    const AudioParamHDF param = {
+        .sampleRate = SAMPLE_RATE_8000,
+        .channelMask = STEREO,
+        .bitFormat = SAMPLE_U8,
+        .streamUsage = STREAM_USAGE_VOICE_COMMUNICATION,
+        .frameSize = 30,
+        .period = 0,
+        .ext = "Test",
+    };
+    std::vector<AudioCodecType> container = spk_->codec_;
+    spk_->codec_.clear();
+    spk_->GetCodecCaps(OHOS::DistributedHardware::AAC);
+    spk_->GetCodecCaps(OHOS::DistributedHardware::OPUS);
+    auto ret = spk_->SetParameters(streamId_, param);
+    spk_->GetAudioParam();
+    spk_->codec_ = container;
+    EXPECT_EQ(DH_SUCCESS, ret);
+}
+
 /**
  * @tc.name: NotifyEvent_001
  * @tc.desc: Verify NotifyEvent function.
@@ -455,5 +482,55 @@ HWTEST_F(DSpeakerDevTest, SendMessage_001, TestSize.Level1)
     spk_->InitCtrlTrans();
     EXPECT_EQ(DH_SUCCESS, spk_->SendMessage(OPEN_SPEAKER, content, dstDevId));
 }
+
+/**
+ * @tc.name: AddToVec_001
+ * @tc.desc: Verify AddToVec function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DSpeakerDevTest, AddToVec_001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container;
+    spk_->AddToVec(container, AudioCodecType::AUDIO_CODEC_AAC);
+    EXPECT_EQ(1, container.size());
+}
+
+/**
+ * @tc.name: GetCodecCaps_001
+ * @tc.desc: Verify GetCodecCaps function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DSpeakerDevTest, GetCodecCaps_001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container = spk_->codec_;
+    spk_->codec_.clear();
+    spk_->GetCodecCaps(OHOS::DistributedHardware::AAC);
+    auto num = spk_->codec_.size();
+    EXPECT_EQ(1, num);
+    spk_->GetCodecCaps(OHOS::DistributedHardware::OPUS);
+    num = spk_->codec_.size();
+    spk_->codec_ = container;
+    EXPECT_EQ(2, num);
+}
+
+/**
+ * @tc.name: IsMimeSupported_001
+ * @tc.desc: Verify IsMimeSupported function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DSpeakerDevTest, IsMimeSupported_001, TestSize.Level1)
+{
+    std::vector<AudioCodecType> container = spk_->codec_;
+    spk_->codec_.clear();
+    spk_->GetCodecCaps(OHOS::DistributedHardware::AAC);
+    bool ret = spk_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_AAC_EN);
+    EXPECT_EQ(ret, true);
+    ret = spk_->IsMimeSupported(AudioCodecType::AUDIO_CODEC_OPUS);
+    spk_->codec_ = container;
+    EXPECT_EQ(ret, false);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/common/audioparam/audio_param.h b/services/common/audioparam/audio_param.h
index 95d36594880d4bcba4e6ccd0c8610cbfc935019e..1b03f4d81065bee02db22677d3522408a7d983c6 100644
--- a/services/common/audioparam/audio_param.h
+++ b/services/common/audioparam/audio_param.h
@@ -58,7 +58,8 @@ typedef enum {
 typedef enum {
     AUDIO_CODEC_AAC = 0,
     AUDIO_CODEC_FLAC = 1,
-    AUDIO_CODEC_AAC_EN = 2
+    AUDIO_CODEC_AAC_EN = 2,
+    AUDIO_CODEC_OPUS = 3
 } AudioCodecType;
 
 typedef enum {