diff --git a/services/audioclient/micclient/include/dmic_client.h b/services/audioclient/micclient/include/dmic_client.h
index d3a0dd0c77c7b496afabd2032b8c63e09c689678..4eff5770cb10256e527511aece9f2c331c9f76a5 100644
--- a/services/audioclient/micclient/include/dmic_client.h
+++ b/services/audioclient/micclient/include/dmic_client.h
@@ -40,6 +40,9 @@
 #include "iaudio_event_callback.h"
 #include "imic_client.h"
 
+#include "v1_0/audio_types.h"
+#include "v1_0/iaudio_manager.h"
+
 namespace OHOS {
 namespace DistributedHardware {
 class DMicClient : public IAudioDataTransCallback,
@@ -62,6 +65,25 @@ public:
     void SetAttrs(const std::string &devId, const std::shared_ptr<IAudioEventCallback> &callback) override;
     int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override;
 
+    void AdapterDescFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
+    void ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
+    int32_t GetAudioManager();
+    int32_t GetAdapter();
+    int32_t GetPrimaryDesc(struct AudioAdapterDescriptor *descs, struct AudioAdapterDescriptor
+        **primaryDesc);
+    void ReleaseHDFAudioDevice();
+    int32_t InitHDFAudioDevice();
+    void GenerateAttr(const AudioParam &param);
+    int32_t AudioFwkClientSetUp();
+    int32_t HdfClientSetUp();
+    int32_t TransSetUp();
+    int32_t HdfClientRelease();
+    int32_t TransRelease();
+    int32_t HdfClientStartCapture();
+    void HdfCaptureAudioData(uint32_t lengthPerCapture, const uint32_t lengthPerTrans,
+        const uint32_t len);
+    void AudioFwkCaptureData();
+
     void OnReadData(size_t length) override;
 private:
     void CaptureThreadRunning();
@@ -83,6 +105,27 @@ private:
     std::shared_ptr<IAudioDataTransport> micTrans_ = nullptr;
     int64_t lastCaptureStartTime_ = 0;
     int64_t lastTransStartTime_ = 0;
+
+    constexpr static uint8_t PORT_ID = 11;
+    constexpr static size_t FRAME_PER_SECOND = 50;
+    constexpr static size_t MAX_AUDIO_ADAPTER_DESC = 5;
+    constexpr static size_t PATH_LEN = 256;
+    constexpr static size_t INT_32_MAX = 0x7fffffff;
+    constexpr static size_t BUFFER_PERIOD_SIZE = 4096;
+    constexpr static size_t AUDIO_BUFFER_SIZE = 16384;
+    constexpr static size_t FORMATNUM = 2;
+    static constexpr const char* ADAPTERNAME = "primary";
+    static constexpr const char* DEVNAME = "devName";
+
+    char adapterName_[PATH_LEN] = {0};
+    struct IAudioManager *audioManager_ = nullptr;
+    struct IAudioAdapter *audioAdapter_ = nullptr;
+    struct IAudioCapture *hdfCapture_ = nullptr;
+    uint32_t captureId_ = 0;
+    int64_t frameIndex_ = 0;
+    bool micInUse_ = false;
+    struct AudioDeviceDescriptor captureDesc_;
+    struct AudioSampleAttributes captureAttr_;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp
index 87bfc54ce3fa712cd374a1d799bab4d2c221975a..a75ee623297fd8511b749f07be2cababf01cd6f3 100644
--- a/services/audioclient/micclient/src/dmic_client.cpp
+++ b/services/audioclient/micclient/src/dmic_client.cpp
@@ -20,6 +20,7 @@
 #include "daudio_constants.h"
 #include "daudio_hisysevent.h"
 #include "daudio_sink_manager.h"
+#include "daudio_sink_hidumper.h"
 
 #undef DH_LOG_TAG
 #define DH_LOG_TAG "DMicClient"
@@ -78,10 +79,11 @@ int32_t DMicClient::OnStateChange(const AudioEventType type)
     switch (type) {
         case AudioEventType::DATA_OPENED: {
             isBlocking_.store(true);
-            if (audioParam_.captureOpts.capturerFlags != MMAP_MODE) {
-                isCaptureReady_.store(true);
-                captureDataThread_ = std::thread(&DMicClient::CaptureThreadRunning, this);
+            isCaptureReady_.store(true);
+            if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+                frameIndex_ = 0;
             }
+            captureDataThread_ = std::thread(&DMicClient::CaptureThreadRunning, this);
             event.type = AudioEventType::MIC_OPENED;
             break;
         }
@@ -103,13 +105,165 @@ int32_t DMicClient::OnStateChange(const AudioEventType type)
     return DH_SUCCESS;
 }
 
-int32_t DMicClient::SetUp(const AudioParam &param)
+void DMicClient::AdapterDescFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
+{
+    if (dataBlock == nullptr) {
+        return;
+    }
+    if (dataBlock->adapterName != nullptr) {
+        free(dataBlock->adapterName);
+        dataBlock->adapterName = nullptr;
+    }
+    if (dataBlock->ports != nullptr) {
+        free(dataBlock->ports);
+        dataBlock->ports = nullptr;
+    }
+    if (freeSelf) {
+        free(dataBlock);
+        dataBlock = nullptr;
+    }
+}
+
+void DMicClient::ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
+{
+    if (descsLen > 0 && descs != nullptr && (*descs) != nullptr) {
+        for (uint32_t i = 0; i < descsLen; i++) {
+            AdapterDescFree(&(*descs)[i], false);
+        }
+        free(*descs);
+        *descs = nullptr;
+    }
+}
+
+int32_t DMicClient::GetAudioManager()
+{
+    audioManager_ = IAudioManagerGet(false);
+    if (audioManager_ == nullptr) {
+        DHLOGE("Get audio manager fail");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    return DH_SUCCESS;
+}
+
+int32_t DMicClient::GetAdapter()
+{
+    size_t adapterSize = sizeof(struct AudioAdapterDescriptor) * (MAX_AUDIO_ADAPTER_DESC);
+    struct AudioAdapterDescriptor *descs = reinterpret_cast<struct AudioAdapterDescriptor *>(malloc(adapterSize));
+    if (descs == nullptr) {
+        DHLOGE("malloc for descs failed");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    if (memset_s(descs, adapterSize, 0, adapterSize) != EOK) {
+        DHLOGE("memset for descs failed");
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    uint32_t size = MAX_AUDIO_ADAPTER_DESC;
+    if (audioManager_ == nullptr) {
+        DHLOGE("AudioManager is nullptr");
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    int32_t ret = audioManager_->GetAllAdapters(audioManager_, descs, &size);
+    if (size == 0 || descs == nullptr || ret != 0) {
+        DHLOGE("Get audio adapters failed. ret : %d.", ret);
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    struct AudioAdapterDescriptor *primaryDesc = nullptr;
+    if (GetPrimaryDesc(descs, &primaryDesc) != DH_SUCCESS) {
+        return ERR_DH_AUDIO_FAILED;
+    }
+    ret = audioManager_->LoadAdapter(audioManager_, primaryDesc, &audioAdapter_);
+    if (ret != DH_SUCCESS || audioAdapter_ == nullptr) {
+        DHLOGE("Load primary adapter failed.");
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+    (void)audioAdapter_->InitAllPorts(audioAdapter_);
+    return DH_SUCCESS;
+}
+
+int32_t DMicClient::GetPrimaryDesc(struct AudioAdapterDescriptor *descs, struct AudioAdapterDescriptor
+    **primaryDesc)
+{
+    uint32_t size = MAX_AUDIO_ADAPTER_DESC;
+    for (uint32_t index = 0; index < size; index++) {
+        auto desc = &descs[index];
+        if (desc == nullptr || desc->adapterName == nullptr) {
+            continue;
+        }
+        if (!strcmp(desc->adapterName, ADAPTERNAME)) {
+            *primaryDesc = desc;
+            break;
+        }
+    }
+    if (*primaryDesc == nullptr) {
+        DHLOGE("Find primary adapter failed.");
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    if (strcpy_s(adapterName_, PATH_LEN, (*primaryDesc)->adapterName) < 0) {
+        DHLOGE("Strcpy adapter name failed.");
+        ReleaseAdapterDescs(&descs, MAX_AUDIO_ADAPTER_DESC);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    return DH_SUCCESS;
+}
+
+void DMicClient::ReleaseHDFAudioDevice()
+{
+    if (micInUse_) {
+        return;
+    }
+    if (audioManager_ != nullptr && audioManager_->UnloadAdapter != nullptr) {
+        audioManager_->UnloadAdapter(audioManager_, adapterName_);
+        IAudioAdapterRelease(audioAdapter_, false);
+        audioAdapter_ = nullptr;
+        IAudioManagerRelease(audioManager_, false);
+        audioManager_ = nullptr;
+    }
+}
+
+int32_t DMicClient::InitHDFAudioDevice()
+{
+    if (micInUse_) {
+        return DH_SUCCESS;
+    }
+    if (GetAudioManager() != DH_SUCCESS) {
+        DHLOGE("Get audio manager failed");
+        ReleaseHDFAudioDevice();
+        return ERR_DH_AUDIO_FAILED;
+    }
+
+    if (GetAdapter() != DH_SUCCESS) {
+        DHLOGE("Get audio adapter failed");
+        ReleaseHDFAudioDevice();
+        return ERR_DH_AUDIO_FAILED;
+    }
+    return DH_SUCCESS;
+}
+
+void DMicClient::GenerateAttr(const AudioParam &param)
+{
+    captureDesc_.portId = PORT_ID;
+    captureDesc_.pins = AudioPortPin::PIN_IN_MIC;
+    captureDesc_.desc = strdup(DEVNAME);
+    captureAttr_.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
+    captureAttr_.interleaved = 0;
+    captureAttr_.type = AUDIO_IN_MEDIA;
+    captureAttr_.period = BUFFER_PERIOD_SIZE;
+    captureAttr_.isBigEndian = false;
+    captureAttr_.isSignedData = true;
+    captureAttr_.stopThreshold = INT_32_MAX;
+    captureAttr_.silenceThreshold = AUDIO_BUFFER_SIZE;
+    captureAttr_.channelCount = param.comParam.channelMask;
+    captureAttr_.sampleRate = param.comParam.sampleRate;
+}
+
+int32_t DMicClient::AudioFwkClientSetUp()
 {
-    DHLOGI("Set up mic client, param: {sampleRate: %d, bitFormat: %d," +
-        "channelMask: %d, sourceType: %d, capturerFlags: %d, frameSize: %d}.",
-        param.comParam.sampleRate, param.comParam.bitFormat, param.comParam.channelMask, param.captureOpts.sourceType,
-        param.captureOpts.capturerFlags, param.comParam.frameSize);
-    audioParam_ = param;
     AudioStandard::AudioCapturerOptions capturerOptions = {
         {
             static_cast<AudioStandard::AudioSamplingRate>(audioParam_.comParam.sampleRate),
@@ -119,7 +273,7 @@ int32_t DMicClient::SetUp(const AudioParam &param)
         },
         {
             static_cast<AudioStandard::SourceType>(audioParam_.captureOpts.sourceType),
-            audioParam_.captureOpts.capturerFlags == MMAP_MODE ? AudioStandard::STREAM_FLAG_FAST : 0,
+            0,
         }
     };
     std::lock_guard<std::mutex> lck(devMtx_);
@@ -135,7 +289,34 @@ int32_t DMicClient::SetUp(const AudioParam &param)
             return ERR_DH_AUDIO_CLIENT_CREATE_CAPTURER_FAILED;
         }
     }
+    return TransSetUp();
+}
+
+int32_t DMicClient::HdfClientSetUp()
+{
+    if (InitHDFAudioDevice() != DH_SUCCESS) {
+        DHLOGE("Init hdf audio device failed.");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    GenerateAttr(audioParam_);
+
+    if (audioAdapter_ == nullptr) {
+        DHLOGE("audio adapter is null");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    int32_t ret = audioAdapter_->CreateCapture(audioAdapter_, &captureDesc_, &captureAttr_,
+        &hdfCapture_, &captureId_);
+    if (ret != DH_SUCCESS || hdfCapture_ == nullptr) {
+        DHLOGE("CreateCapture failed, ret: %d.", ret);
+        return ERR_DH_AUDIO_FAILED;
+    }
+    micInUse_ = true;
+    DHLOGI("Create hdf audio capture success");
+    return TransSetUp();
+}
 
+int32_t DMicClient::TransSetUp()
+{
     if (micTrans_ == nullptr) {
         DHLOGE("mic trans in engine should be init by dev.");
         return ERR_DH_AUDIO_NULLPTR;
@@ -149,6 +330,84 @@ int32_t DMicClient::SetUp(const AudioParam &param)
     return DH_SUCCESS;
 }
 
+int32_t DMicClient::HdfClientRelease()
+{
+    DHLOGI("Release hdf mic client.");
+    if (audioAdapter_ != nullptr) {
+        audioAdapter_->DestroyCapture(audioAdapter_, captureId_);
+    }
+    IAudioCaptureRelease(hdfCapture_, false);
+    hdfCapture_ = nullptr;
+    micInUse_ = false;
+    ReleaseHDFAudioDevice();
+    DHLOGI("Release hdf audio capture success.");
+    return TransRelease();
+}
+
+int32_t DMicClient::TransRelease()
+{
+    if (micTrans_ == nullptr) {
+        DHLOGE("Mic trans is nullptr.");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    if (micTrans_->Release() != DH_SUCCESS) {
+        DHLOGE("Mic trans release failed.");
+    }
+    micTrans_ = nullptr;
+    clientStatus_ = AudioStatus::STATUS_IDLE;
+    return DH_SUCCESS;
+}
+
+int32_t DMicClient::HdfClientStartCapture()
+{
+    if (hdfCapture_ == nullptr) {
+        DHLOGE("Audio capturer is nullptr, can not start.");
+        return ERR_DH_AUDIO_FAILED;
+    }
+    hdfCapture_->Start(hdfCapture_);
+    DHLOGI("Start hdf capture success.");
+    return DH_SUCCESS;
+}
+
+void DMicClient::HdfCaptureAudioData(uint32_t lengthPerCapture, const uint32_t lengthPerTrans,
+    const uint32_t len)
+{
+    auto audioData = std::make_shared<AudioData>(lengthPerCapture);
+    uint64_t size = 0;
+    if (hdfCapture_ == nullptr) {
+        DHLOGE("hdf capture is nullptr.");
+        return;
+    }
+    hdfCapture_->CaptureFrame(hdfCapture_, reinterpret_cast<int8_t *>(audioData->Data()),
+        &lengthPerCapture, &size);
+    DHLOGD("CaptureFrame success, framesize: %d", lengthPerCapture);
+
+    for (uint32_t i = 0; i < len; i++) {
+        std::shared_ptr<AudioData> data = std::make_shared<AudioData>(lengthPerTrans);
+        if (memcpy_s(data->Data(), lengthPerTrans, audioData->Data() + lengthPerTrans * i,
+            lengthPerTrans) != EOK) {
+            DHLOGE("Copy audio data %d failed.", i);
+        }
+        int32_t ret = micTrans_->FeedAudioData(data);
+        if (ret != DH_SUCCESS) {
+            DHLOGE("Failed to send data %d.", i);
+        }
+    }
+}
+
+int32_t DMicClient::SetUp(const AudioParam &param)
+{
+    DHLOGI("Set up mic client, param: {sampleRate: %d, bitFormat: %d," +
+        "channelMask: %d, sourceType: %d, capturerFlags: %d, frameSize: %d}.",
+        param.comParam.sampleRate, param.comParam.bitFormat, param.comParam.channelMask, param.captureOpts.sourceType,
+        param.captureOpts.capturerFlags, param.comParam.frameSize);
+    audioParam_ = param;
+    if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+        return HdfClientSetUp();
+    }
+    return AudioFwkClientSetUp();
+}
+
 int32_t DMicClient::SendMessage(uint32_t type, std::string content, std::string dstDevId)
 {
     DHLOGI("Send message to remote.");
@@ -174,41 +433,39 @@ int32_t DMicClient::Release()
         DHLOGE("Mic status is wrong or mic trans is null, %d.", (int32_t)clientStatus_);
         return ERR_DH_AUDIO_SA_STATUS_ERR;
     }
-    bool status = true;
-    if (!audioCapturer_->Release()) {
-        DHLOGE("Audio capturer release failed.");
-        status = false;
-    }
-    int32_t ret = micTrans_->Release();
-    if (ret != DH_SUCCESS) {
-        DHLOGE("Mic trans release failed.");
-        status = false;
+    if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+        return HdfClientRelease();
     }
-    micTrans_ = nullptr;
-    clientStatus_ = AudioStatus::STATUS_IDLE;
-    if (!status) {
-        return ERR_DH_AUDIO_FAILED;
+    if (audioCapturer_ == nullptr || !audioCapturer_->Release()) {
+        DHLOGE("Audio capturer release failed.");
     }
-    return DH_SUCCESS;
+    return TransRelease();
 }
 
 int32_t DMicClient::StartCapture()
 {
     DHLOGI("Start capturer.");
     std::lock_guard<std::mutex> lck(devMtx_);
-    if (audioCapturer_ == nullptr || micTrans_ == nullptr || clientStatus_ != AudioStatus::STATUS_READY) {
+    if (micTrans_ == nullptr || clientStatus_ != AudioStatus::STATUS_READY) {
         DHLOGE("Audio capturer init failed or mic status wrong, status: %d.", (int32_t)clientStatus_);
         DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ERR_DH_AUDIO_SA_STATUS_ERR,
             "daudio init failed or mic status wrong.");
         return ERR_DH_AUDIO_SA_STATUS_ERR;
     }
-
-    if (!audioCapturer_->Start()) {
-        DHLOGE("Audio capturer start failed.");
-        audioCapturer_->Release();
-        DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL, ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED,
-            "daudio capturer start failed.");
-        return ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED;
+    if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+        HdfClientStartCapture();
+    } else {
+        if (audioCapturer_ == nullptr) {
+            DHLOGE("audio capturer is nullptr.");
+            return ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED;
+        }
+        if (!audioCapturer_->Start()) {
+            DHLOGE("Audio capturer start failed.");
+            audioCapturer_->Release();
+            DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL,
+                ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED, "daudio capturer start failed.");
+            return ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED;
+        }
     }
     int32_t ret = micTrans_->Start();
     if (ret != DH_SUCCESS) {
@@ -221,48 +478,75 @@ int32_t DMicClient::StartCapture()
     return DH_SUCCESS;
 }
 
+void DMicClient::AudioFwkCaptureData()
+{
+    std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(audioParam_.comParam.frameSize);
+    size_t bytesRead = 0;
+    bool errorFlag = false;
+    int64_t startTime = GetNowTimeUs();
+    if (audioCapturer_ == nullptr) {
+        DHLOGE("audio capturer is nullptr");
+        return;
+    }
+    while (bytesRead < audioParam_.comParam.frameSize) {
+        int32_t len = audioCapturer_->Read(*(audioData->Data() + bytesRead),
+            audioParam_.comParam.frameSize - bytesRead, isBlocking_.load());
+        if (len >= 0) {
+            bytesRead += static_cast<size_t>(len);
+        } else {
+            errorFlag = true;
+            break;
+        }
+        int64_t endTime = GetNowTimeUs();
+        if (IsOutDurationRange(startTime, endTime, lastCaptureStartTime_)) {
+            DHLOGE("This time capture spend: %lld, The interval of capture this time and the last time: %lld",
+                endTime - startTime, startTime - lastCaptureStartTime_);
+        }
+        lastCaptureStartTime_ = startTime;
+    }
+    if (errorFlag) {
+        DHLOGE("Bytes read failed.");
+        return;
+    }
+    if (DaudioSinkHidumper::GetInstance().GetFlagStatus()) {
+        SaveFile(FILE_NAME, const_cast<uint8_t*>(audioData->Data()), audioData->Size());
+    }
+    int64_t startTransTime = GetNowTimeUs();
+    int32_t ret = micTrans_->FeedAudioData(audioData);
+    if (ret != DH_SUCCESS) {
+        DHLOGE("Failed to send data.");
+    }
+    int64_t endTransTime = GetNowTimeUs();
+    if (IsOutDurationRange(startTransTime, endTransTime, lastTransStartTime_)) {
+        DHLOGE("This time send data spend: %lld, The interval of send data this time and the last time: %lld",
+            endTransTime - startTransTime, startTransTime - lastTransStartTime_);
+    }
+    lastTransStartTime_ = startTransTime;
+}
+
 void DMicClient::CaptureThreadRunning()
 {
     DHLOGD("Start the capturer thread.");
     if (pthread_setname_np(pthread_self(), CAPTURETHREAD) != DH_SUCCESS) {
         DHLOGE("Capture data thread setname failed.");
     }
+    uint32_t lengthPerCapture;
+    uint32_t lengthPerTrans;
+    uint32_t len;
+    if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+        lengthPerCapture = (audioParam_.comParam.sampleRate * audioParam_.comParam.bitFormat *
+            FORMATNUM * audioParam_.comParam.channelMask) / FRAME_PER_SECOND;
+        lengthPerTrans = audioParam_.comParam.frameSize;
+        len = lengthPerCapture / lengthPerTrans;
+    }
     while (isCaptureReady_.load()) {
-        std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(audioParam_.comParam.frameSize);
-        size_t bytesRead = 0;
-        bool errorFlag = false;
-        int64_t startTime = GetNowTimeUs();
-        while (bytesRead < audioParam_.comParam.frameSize) {
-            int32_t len = audioCapturer_->Read(*(audioData->Data() + bytesRead),
-                audioParam_.comParam.frameSize - bytesRead, isBlocking_.load());
-            if (len >= 0) {
-                bytesRead += static_cast<size_t>(len);
-            } else {
-                errorFlag = true;
-                break;
-            }
-            int64_t endTime = GetNowTimeUs();
-            if (IsOutDurationRange(startTime, endTime, lastCaptureStartTime_)) {
-                DHLOGE("This time capture spend: %lld, The interval of capture this time and the last time: %lld",
-                    endTime - startTime, startTime - lastCaptureStartTime_);
-            }
-            lastCaptureStartTime_ = startTime;
+        if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+            DHLOGD("Capture frameIndex: %lld.", frameIndex_);
+            HdfCaptureAudioData(lengthPerCapture, lengthPerTrans, len);
+            ++frameIndex_;
+        } else {
+            AudioFwkCaptureData();
         }
-        if (errorFlag) {
-            DHLOGE("Bytes read failed.");
-            break;
-        }
-        int64_t startTransTime = GetNowTimeUs();
-        int32_t ret = micTrans_->FeedAudioData(audioData);
-        if (ret != DH_SUCCESS) {
-            DHLOGE("Failed to send data.");
-        }
-        int64_t endTransTime = GetNowTimeUs();
-        if (IsOutDurationRange(startTransTime, endTransTime, lastTransStartTime_)) {
-            DHLOGE("This time send data spend: %lld, The interval of send data this time and the last time: %lld",
-                endTransTime - startTransTime, startTransTime - lastTransStartTime_);
-        }
-        lastTransStartTime_ = startTransTime;
     }
 }
 
@@ -312,7 +596,7 @@ int32_t DMicClient::StopCapture()
             "daudio capturer is not start or mic status wrong.");
         return ERR_DH_AUDIO_SA_STATUS_ERR;
     }
-    if (audioCapturer_ == nullptr || micTrans_ == nullptr) {
+    if (micTrans_ == nullptr) {
         DHLOGE("The capturer or mictrans is not instantiated.");
         DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_OPT_FAIL,
             ERR_DH_AUDIO_CLIENT_CAPTURER_OR_MICTRANS_INSTANCE, "daudio capturer or mictrans is not instantiated.");
@@ -320,11 +604,9 @@ int32_t DMicClient::StopCapture()
     }
 
     isBlocking_.store(false);
-    if (audioParam_.captureOpts.capturerFlags != MMAP_MODE) {
-        isCaptureReady_.store(false);
-        if (captureDataThread_.joinable()) {
-            captureDataThread_.join();
-        }
+    isCaptureReady_.store(false);
+    if (captureDataThread_.joinable()) {
+        captureDataThread_.join();
     }
 
     bool status = true;
@@ -333,9 +615,15 @@ int32_t DMicClient::StopCapture()
         DHLOGE("Mic trans stop failed.");
         status = false;
     }
-    if (!audioCapturer_->Stop()) {
-        DHLOGE("Audio capturer stop failed.");
-        status = false;
+    if (audioParam_.captureOpts.capturerFlags == MMAP_MODE) {
+        if (hdfCapture_ != nullptr) {
+            hdfCapture_->Stop(hdfCapture_);
+        }
+    } else {
+        if (audioCapturer_ == nullptr || !audioCapturer_->Stop()) {
+            DHLOGE("Audio capturer stop failed.");
+            status = false;
+        }
     }
     clientStatus_ = AudioStatus::STATUS_STOP;
     if (!status) {
diff --git a/services/audioclient/test/unittest/micclient/BUILD.gn b/services/audioclient/test/unittest/micclient/BUILD.gn
index aeec741c8fb5ba1f644588a8cbeed5c6372e33bd..9d0c2f90a0aea2c6a26065da2eb57a7074b75def 100644
--- a/services/audioclient/test/unittest/micclient/BUILD.gn
+++ b/services/audioclient/test/unittest/micclient/BUILD.gn
@@ -67,6 +67,7 @@ ohos_unittest("MicClientTest") {
     "audio_framework:audio_capturer",
     "distributed_hardware_fwk:distributed_av_receiver",
     "distributed_hardware_fwk:distributed_av_sender",
+    "drivers_interface_audio:libaudio_proxy_1.0",
   ]
 }