diff --git a/frameworks/native/capi/screencapture/native_avscreen_capture.cpp b/frameworks/native/capi/screencapture/native_avscreen_capture.cpp
index cb5cdfe762ecb576020fd06bf6996704abef49d9..eaf888bd0f8761731bf002888cf5bc1392f7bc7d 100644
--- a/frameworks/native/capi/screencapture/native_avscreen_capture.cpp
+++ b/frameworks/native/capi/screencapture/native_avscreen_capture.cpp
@@ -144,6 +144,7 @@ private:
         CHECK_AND_RETURN_RET_LOG(screenCaptureObj->screenCapture_ != nullptr,
             AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture is null");
 
+        MEDIA_LOGD("OnProcessAudioBuffer() is called, bufferType %{public}d", bufferType);
         AudioCaptureSourceType audioSourceType;
         if (bufferType == OH_AVScreenCaptureBufferType::OH_SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
             audioSourceType = AudioCaptureSourceType::ALL_PLAYBACK;
@@ -342,11 +343,11 @@ public:
 
 private:
     std::shared_mutex mutex_;
-    struct OH_AVScreenCapture *capture_;
+    struct OH_AVScreenCapture *capture_ = nullptr;
     struct OH_AVScreenCaptureCallback callback_;
-    std::shared_ptr<NativeScreenCaptureStateChangeCallback> stateChangeCallback_;
-    std::shared_ptr<NativeScreenCaptureErrorCallback> errorCallback_;
-    std::shared_ptr<NativeScreenCaptureDataCallback> dataCallback_;
+    std::shared_ptr<NativeScreenCaptureStateChangeCallback> stateChangeCallback_ = nullptr;
+    std::shared_ptr<NativeScreenCaptureErrorCallback> errorCallback_ = nullptr;
+    std::shared_ptr<NativeScreenCaptureDataCallback> dataCallback_ = nullptr;
 };
 
 struct ScreenCaptureContentFilterObject : public OH_AVScreenCapture_ContentFilter {
@@ -730,11 +731,17 @@ OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetMicrophoneEnabled(struct OH_AV
 static OH_AVSCREEN_CAPTURE_ErrCode AVScreenCaptureSetCallback(struct OH_AVScreenCapture *capture,
     struct ScreenCaptureObject *screenCaptureObj)
 {
+    MEDIA_LOGD("AVScreenCaptureSetCallback S");
     CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
     CHECK_AND_RETURN_RET_LOG(screenCaptureObj != nullptr && screenCaptureObj->screenCapture_ != nullptr,
         AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "screenCapture_ is nullptr!");
     if (screenCaptureObj->callback_ == nullptr) {
-        OH_AVScreenCaptureCallback dummyCallback = { nullptr, nullptr, nullptr };
+        MEDIA_LOGD("AVScreenCaptureSetCallback new NativeScreenCaptureCallback");
+        OH_AVScreenCaptureCallback dummyCallback = {
+            .onError = nullptr,
+            .onAudioBufferAvailable = nullptr,
+            .onVideoBufferAvailable = nullptr
+        };
         screenCaptureObj->callback_ = std::make_shared<NativeScreenCaptureCallback>(capture, dummyCallback);
         CHECK_AND_RETURN_RET_LOG(screenCaptureObj->callback_ != nullptr,
             AV_SCREEN_CAPTURE_ERR_NO_MEMORY, "callback_ is nullptr!");
@@ -743,12 +750,14 @@ static OH_AVSCREEN_CAPTURE_ErrCode AVScreenCaptureSetCallback(struct OH_AVScreen
         CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, AV_SCREEN_CAPTURE_ERR_OPERATE_NOT_PERMIT,
             "SetScreenCaptureCallback failed!");
     }
+    MEDIA_LOGD("AVScreenCaptureSetCallback E");
     return AV_SCREEN_CAPTURE_ERR_OK;
 }
 
 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetStateCallback(struct OH_AVScreenCapture *capture,
     OH_AVScreenCapture_OnStateChange callback, void *userData)
 {
+    MEDIA_LOGD("OH_AVScreenCapture_SetStateCallback S");
     CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input stateCallback is nullptr!");
     struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
@@ -760,14 +769,17 @@ OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetStateCallback(struct OH_AVScre
 
     if (screenCaptureObj->callback_ == nullptr ||
         !screenCaptureObj->callback_->SetStateChangeCallback(callback, userData)) {
+        MEDIA_LOGE("OH_AVScreenCapture_SetStateCallback error");
         return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
     }
+    MEDIA_LOGD("OH_AVScreenCapture_SetStateCallback E");
     return AV_SCREEN_CAPTURE_ERR_OK;
 }
 
 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetErrorCallback(struct OH_AVScreenCapture *capture,
     OH_AVScreenCapture_OnError callback, void *userData)
 {
+    MEDIA_LOGD("OH_AVScreenCapture_SetErrorCallback S");
     CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input errorCallback is nullptr!");
     struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
@@ -778,14 +790,17 @@ OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetErrorCallback(struct OH_AVScre
     CHECK_AND_RETURN_RET_LOG(errCode == AV_SCREEN_CAPTURE_ERR_OK, errCode, "SetErrorCallback is null");
 
     if (screenCaptureObj->callback_ == nullptr || !screenCaptureObj->callback_->SetErrorCallback(callback, userData)) {
+        MEDIA_LOGE("OH_AVScreenCapture_SetErrorCallback error");
         return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
     }
+    MEDIA_LOGD("OH_AVScreenCapture_SetErrorCallback E");
     return AV_SCREEN_CAPTURE_ERR_OK;
 }
 
 OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetDataCallback(struct OH_AVScreenCapture *capture,
     OH_AVScreenCapture_OnBufferAvailable callback, void *userData)
 {
+    MEDIA_LOGD("OH_AVScreenCapture_SetDataCallback E");
     CHECK_AND_RETURN_RET_LOG(capture != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input capture is nullptr!");
     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AV_SCREEN_CAPTURE_ERR_INVALID_VAL, "input dataCallback is nullptr!");
     struct ScreenCaptureObject *screenCaptureObj = reinterpret_cast<ScreenCaptureObject *>(capture);
@@ -797,8 +812,10 @@ OH_AVSCREEN_CAPTURE_ErrCode OH_AVScreenCapture_SetDataCallback(struct OH_AVScree
 
     if (screenCaptureObj->callback_ == nullptr ||
         !screenCaptureObj->callback_->SetDataCallback(callback, userData)) {
+        MEDIA_LOGE("OH_AVScreenCapture_SetErrorCallback error");
         return AV_SCREEN_CAPTURE_ERR_NO_MEMORY;
     }
+    MEDIA_LOGD("OH_AVScreenCapture_SetDataCallback E");
     return AV_SCREEN_CAPTURE_ERR_OK;
 }
 
diff --git a/interfaces/inner_api/native/screen_capture.h b/interfaces/inner_api/native/screen_capture.h
index 480e6cb039630584e15fdaeb36995d4e6a6c3b7a..dcebbcf414fa3f5ed7621093039b9f87add27021 100644
--- a/interfaces/inner_api/native/screen_capture.h
+++ b/interfaces/inner_api/native/screen_capture.h
@@ -114,6 +114,8 @@ enum AVScreenCaptureStateCode {
 };
 
 enum AVScreenCaptureBufferType {
+    /* Buffer of video data from screen */
+    SCREEN_CAPTURE_BUFFERTYPE_INVALID = -1,
     /* Buffer of video data from screen */
     SCREEN_CAPTURE_BUFFERTYPE_VIDEO = 0,
     /* Buffer of audio data from inner capture */
diff --git a/services/services/screen_capture/ipc/screen_capture_listener_stub.cpp b/services/services/screen_capture/ipc/screen_capture_listener_stub.cpp
index 65d89fb1d01f4d24d94a2611f3d30050de827054..f007f2d19359198a1388803e8dd6b885592d7245 100644
--- a/services/services/screen_capture/ipc/screen_capture_listener_stub.cpp
+++ b/services/services/screen_capture/ipc/screen_capture_listener_stub.cpp
@@ -36,6 +36,7 @@ ScreenCaptureListenerStub::~ScreenCaptureListenerStub()
 int ScreenCaptureListenerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
     MessageOption &option)
 {
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances OnRemoteRequest code:%{public}u", FAKE_POINTER(this), code);
     auto remoteDescriptor = data.ReadInterfaceToken();
     if (ScreenCaptureListenerStub::GetDescriptor() != remoteDescriptor) {
         MEDIA_LOGE("Invalid descriptor");
diff --git a/services/services/screen_capture/server/audio_capturer_wrapper.cpp b/services/services/screen_capture/server/audio_capturer_wrapper.cpp
index d391cd966d27297f30ffadb3c986692c596715c4..9afc416732960c732eded10c28829aa8075a5726 100644
--- a/services/services/screen_capture/server/audio_capturer_wrapper.cpp
+++ b/services/services/screen_capture/server/audio_capturer_wrapper.cpp
@@ -19,26 +19,26 @@
 #include "media_errors.h"
 
 namespace {
-constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "ScreenCaptureServer"};
+constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "SC_AudioCapturerWrapper"};
 }
 
 namespace OHOS {
 namespace Media {
 void AudioCapturerCallbackImpl::OnInterrupt(const InterruptEvent &interruptEvent)
 {
-    MEDIA_LOGI("OnInterrupt hintType:%{public}d, eventType:%{public}d, forceType:%{public}d",
+    MEDIA_LOGI("AudioCapturerCallbackImpl OnInterrupt hintType:%{public}d, eventType:%{public}d, forceType:%{public}d",
         interruptEvent.hintType, interruptEvent.eventType, interruptEvent.forceType);
 }
 
 void AudioCapturerCallbackImpl::OnStateChange(const CapturerState state)
 {
-    MEDIA_LOGI("OnStateChange state:%{public}d", state);
+    MEDIA_LOGI("AudioCapturerCallbackImpl OnStateChange state:%{public}d", state);
     switch (state) {
         case CAPTURER_PREPARED:
-            MEDIA_LOGD("OnStateChange CAPTURER_PREPARED");
+            MEDIA_LOGD("AudioCapturerCallbackImpl OnStateChange CAPTURER_PREPARED");
             break;
         default:
-            MEDIA_LOGD("OnStateChange NOT A VALID state");
+            MEDIA_LOGD("AudioCapturerCallbackImpl OnStateChange NOT A VALID state");
             break;
     }
 }
@@ -60,8 +60,8 @@ int32_t AudioCapturerWrapper::Start(const OHOS::AudioStandard::AppInfo &appInfo)
         OnStartFailed(ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_INTERNAL, SCREEN_CAPTURE_ERR_UNKNOWN);
         return MSERR_UNKNOWN;
     }
+    MEDIA_LOGI("0x%{public}06" PRIXPTR "Start success, threadName:%{public}s", FAKE_POINTER(this), threadName_.c_str());
 
-    MEDIA_LOGI("Start success, threadName:%{public}s", threadName_.c_str());
     isRunning_.store(true);
     readAudioLoop_ = std::make_unique<std::thread>(&AudioCapturerWrapper::CaptureAudio, this);
     audioCapturer_ = audioCapturer;
@@ -71,6 +71,7 @@ int32_t AudioCapturerWrapper::Start(const OHOS::AudioStandard::AppInfo &appInfo)
 int32_t AudioCapturerWrapper::Stop()
 {
     std::lock_guard<std::mutex> lock(mutex_);
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Stop S, threadName:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     if (isRunning_.load()) {
         isRunning_.store(false);
         if (readAudioLoop_ != nullptr && readAudioLoop_->joinable()) {
@@ -86,6 +87,7 @@ int32_t AudioCapturerWrapper::Stop()
     }
 
     std::unique_lock<std::mutex> bufferLock(bufferMutex_);
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Stop pop, threadName:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     while (!availBuffers_.empty()) {
         if (availBuffers_.front() != nullptr) {
             free(availBuffers_.front()->buffer);
@@ -93,11 +95,13 @@ int32_t AudioCapturerWrapper::Stop()
         }
         availBuffers_.pop();
     }
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Stop E, threadName:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     return MSERR_OK;
 }
 
 void AudioCapturerWrapper::SetIsMuted(bool isMuted)
 {
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " SetIsMuted isMuted:%{public}d", FAKE_POINTER(this), isMuted);
     isMuted_.store(isMuted);
 }
 
@@ -130,7 +134,7 @@ std::shared_ptr<AudioCapturer> AudioCapturerWrapper::CreateAudioCapturer(const O
 
 int32_t AudioCapturerWrapper::CaptureAudio()
 {
-    MEDIA_LOGI("CaptureAudio start, threadName:%{public}s", threadName_.c_str());
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " CaptureAudio S, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     std::string name = threadName_.substr(0, std::min(threadName_.size(), static_cast<size_t>(MAX_THREAD_NAME_LENGTH)));
     pthread_setname_np(pthread_self(), name.c_str());
 
@@ -166,6 +170,7 @@ int32_t AudioCapturerWrapper::CaptureAudio()
         CHECK_AND_RETURN_RET_LOG(screenCaptureCb_ != nullptr, MSERR_OK, "no consumer, will drop audio frame");
         screenCaptureCb_->OnAudioBufferAvailable(true, audioInfo_.audioSource);
     }
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " CaptureAudio E, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     return MSERR_OK;
 }
 
@@ -174,6 +179,7 @@ int32_t AudioCapturerWrapper::AcquireAudioBuffer(std::shared_ptr<AudioBuffer> &a
     using namespace std::chrono_literals;
     std::unique_lock<std::mutex> lock(bufferMutex_);
     CHECK_AND_RETURN_RET_LOG(isRunning_.load(), MSERR_UNKNOWN, "AcquireAudioBuffer failed, not running");
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Acquire Buffer S, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
 
     if (!bufferCond_.wait_for(
         lock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] { return !availBuffers_.empty(); })) {
@@ -181,6 +187,7 @@ int32_t AudioCapturerWrapper::AcquireAudioBuffer(std::shared_ptr<AudioBuffer> &a
         return MSERR_UNKNOWN;
     }
     audioBuffer = availBuffers_.front();
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Acquire Buffer E, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     return MSERR_OK;
 }
 
@@ -188,9 +195,11 @@ int32_t AudioCapturerWrapper::ReleaseAudioBuffer()
 {
     using namespace std::chrono_literals;
     std::unique_lock<std::mutex> lock(bufferMutex_);
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Release Buffer S, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     CHECK_AND_RETURN_RET_LOG(isRunning_.load(), MSERR_UNKNOWN, "ReleaseAudioBuffer failed, not running");
     CHECK_AND_RETURN_RET_LOG(!availBuffers_.empty(), MSERR_UNKNOWN, "ReleaseAudioBuffer failed, no frame to release");
     availBuffers_.pop();
+    MEDIA_LOGD("0x%{public}06" PRIXPTR " Release Buffer E, name:%{public}s", FAKE_POINTER(this), threadName_.c_str());
     return MSERR_OK;
 }
 
diff --git a/services/services/screen_capture/server/screen_capture_server.cpp b/services/services/screen_capture/server/screen_capture_server.cpp
index f7804a5629c42c5303fe7f0fee54ea77d4fd7a72..5a8421acabb7b4395b68adbc8f4cc67a226e2352 100644
--- a/services/services/screen_capture/server/screen_capture_server.cpp
+++ b/services/services/screen_capture/server/screen_capture_server.cpp
@@ -28,15 +28,28 @@
 #include "screen_capture_listener_proxy.h"
 
 using OHOS::Rosen::DMError;
+
+namespace OHOS {
+namespace Media {
 namespace {
 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "ScreenCaptureServer"};
-static std::map<int32_t, std::shared_ptr<OHOS::Media::ScreenCaptureServer>> serverMap;
+static std::map<int32_t, std::weak_ptr<OHOS::Media::ScreenCaptureServer>> serverMap;
 std::atomic<int32_t> activeSessionId(-1);
+
+// As in the ScreenCaptureServer destructor function mutexGlobal is required to update serverMap
+// MAKE SURE THAT when mutexGlobal is been holding MUST NOT trigger ScreenCaptureServer destructor to be called
 std::mutex mutexGlobal;
+
+std::shared_ptr<OHOS::Media::ScreenCaptureServer> GetScreenCaptureServerByIdWithLock(int32_t id)
+{
+    auto iter = serverMap.find(id);
+    if (iter == serverMap.end()) {
+        return nullptr;
+    }
+    return (iter->second).lock();
+}
 }
 
-namespace OHOS {
-namespace Media {
 static const std::string MP4 = "mp4";
 static const std::string M4A = "m4a";
 
@@ -57,6 +70,7 @@ static const int32_t MICROPHONE_OFF = 0;
 static const int32_t MICROPHONE_STATE_COUNT = 2;
 
 static const int32_t MAX_SESSION_ID = 256;
+static const int32_t MAX_SESSION_PER_UID = 8;
 static const auto NOTIFICATION_SUBSCRIBER = NotificationSubscriber();
 
 void NotificationSubscriber::OnConnected()
@@ -72,15 +86,27 @@ void NotificationSubscriber::OnDisconnected()
 void NotificationSubscriber::OnResponse(int32_t notificationId,
                                         OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption)
 {
-    MEDIA_LOGI("NotificationSubscriber OnResponse notificationId : %{public}d ", notificationId);
-    MEDIA_LOGI("NotificationSubscriber OnResponse ButtonName : %{public}s ", (buttonOption->GetButtonName()).c_str());
+    MEDIA_LOGI("NotificationSubscriber OnResponse notificationId : %{public}d, ButtonName : %{public}s ",
+        notificationId, (buttonOption->GetButtonName()).c_str());
+
+    // To avoid deadlock: first release mutexGlobal, then be destructed
+    std::shared_ptr<OHOS::Media::ScreenCaptureServer> server;
+    {
+        std::unique_lock<std::mutex> lock(mutexGlobal);
+        server = GetScreenCaptureServerByIdWithLock(notificationId);
+    }
+    if (server == nullptr) {
+        MEDIA_LOGW("OnResponse ScreenCaptureServer not exist, notificationId : %{public}d, ButtonName : %{public}s ",
+            notificationId, (buttonOption->GetButtonName()).c_str());
+        return;
+    }
     if (BUTTON_NAME_STOP.compare(buttonOption->GetButtonName()) == 0) {
-        std::shared_ptr<OHOS::Media::ScreenCaptureServer> server = serverMap.at(notificationId);
         server->StopScreenCaptureByEvent(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
+        return;
     }
     if (BUTTON_NAME_MIC.compare(buttonOption->GetButtonName()) == 0) {
-        std::shared_ptr<OHOS::Media::ScreenCaptureServer> server = serverMap.at(notificationId);
         server->UpdateMicrophoneEnabled();
+        return;
     }
 }
 
@@ -93,57 +119,87 @@ std::shared_ptr<IScreenCaptureService> ScreenCaptureServer::Create()
 {
     std::shared_ptr<ScreenCaptureServer> serverTemp = std::make_shared<ScreenCaptureServer>();
     CHECK_AND_RETURN_RET_LOG(serverTemp != nullptr, nullptr, "Failed to new ScreenCaptureServer");
-    
+    int32_t countForUid = 0;
     int32_t newSessionId = 0;
+
+    // To avoid deadlock: first release mutexGlobal, then be destructed
+    std::shared_ptr<ScreenCaptureServer> server;
     for (int32_t i = 0; i < MAX_SESSION_ID; i++) {
-        auto it = serverMap.find(newSessionId);
-        if (it != serverMap.end()) {
+        // To avoid deadlock: first release mutexGlobal, then be destructed
+        {
+            std::unique_lock<std::mutex> lock(mutexGlobal);
+            server = GetScreenCaptureServerByIdWithLock(newSessionId);
+        }
+        if (server != nullptr) {
             newSessionId++;
+            countForUid += (server->appInfo_.appUid == serverTemp->appInfo_.appUid) ? 1 : 0;
+            // To avoid deadlock: first release mutexGlobal, then be destructed
+            // Do this without holding mutexGlobal to avoid dead lock when set nullptr trigger server destruct
+            server = nullptr;
             continue;
         }
-        serverMap.insert(std::make_pair(newSessionId, serverTemp));
+        if (countForUid >= MAX_SESSION_PER_UID) {
+            MEDIA_LOGE("Create failed, uid(%{public}d) has created too many ScreenCaptureServer instances",
+                serverTemp->appInfo_.appUid);
+            return nullptr;
+        }
+        {
+            std::unique_lock<std::mutex> lock(mutexGlobal);
+            serverMap.insert(std::make_pair(newSessionId, serverTemp));
+            MEDIA_LOGI("ScreenCaptureServer::Create newSessionId: %{public}d, serverMap size:%{public}zu",
+                newSessionId, serverMap.size());
+        }
         break;
     }
-    MEDIA_LOGI("ScreenCaptureServer::Create newSessionId: %{public}d", newSessionId);
-    MEDIA_LOGI("ScreenCaptureServer::Create serverMap size : %{public}s",
-        std::to_string(serverMap.size()).c_str());
+
+    if (newSessionId == MAX_SESSION_ID) {
+        MEDIA_LOGE("Create failed for uid(%{public}d), there are too many ScreenCaptureServer instances",
+            serverTemp->appInfo_.appUid);
+        return nullptr;
+    }
     serverTemp->SetSessionId(newSessionId);
-    std::shared_ptr<IScreenCaptureService> server =
-        std::static_pointer_cast<OHOS::Media::IScreenCaptureService>(serverTemp);
-    return server;
+    return std::static_pointer_cast<OHOS::Media::IScreenCaptureService>(serverTemp);
 }
 
 int32_t ScreenCaptureServer::ReportAVScreenCaptureUserChoice(int32_t sessionId, std::string choice)
 {
-    std::lock_guard<std::mutex> lock(mutexGlobal);
-    MEDIA_LOGI("ScreenCaptureServer::ReportAVScreenCaptureUserChoice user sessionId is : %{public}d", sessionId);
-    MEDIA_LOGI("ScreenCaptureServer::ReportAVScreenCaptureUserChoice user choice is : %{public}s", choice.c_str());
+    MEDIA_LOGI("ReportAVScreenCaptureUserChoice sessionId: %{public}d, choice: %{public}s", sessionId, choice.c_str());
+
+    // To avoid deadlock: first release mutexGlobal, then be destructed
     std::shared_ptr<ScreenCaptureServer> server;
-    auto it = serverMap.find(sessionId);
-    if (it != serverMap.end() && it->second != nullptr) {
-        server = it->second;
-    } else {
-        MEDIA_LOGI("ScreenCaptureServer::ReportAVScreenCaptureUserChoice Failed to get report ScreenCaptureServer");
+    {
+        std::lock_guard<std::mutex> lock(mutexGlobal);
+        server = GetScreenCaptureServerByIdWithLock(sessionId);
+    }
+    if (server == nullptr) {
+        MEDIA_LOGE("ReportAVScreenCaptureUserChoice failed to get instance, sessionId: %{public}d", sessionId);
         return MSERR_UNKNOWN;
     }
 
+    // To avoid deadlock: first release mutexGlobal, then be destructed
+    std::shared_ptr<ScreenCaptureServer> currentServer;
     if (USER_CHOICE_ALLOW.compare(choice) == 0) {
+        std::lock_guard<std::mutex> lock(mutexGlobal);
         if (activeSessionId.load() >= 0) {
-            std::shared_ptr<ScreenCaptureServer> currentServer = serverMap.at(activeSessionId.load());
-            currentServer->StopScreenCaptureByEvent(
-                AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER);
+            currentServer = GetScreenCaptureServerByIdWithLock(activeSessionId.load());
+            if (currentServer != nullptr) {
+                MEDIA_LOGW("ReportAVScreenCaptureUserChoice uid(%{public}d) is interrupted by uid(%{public}d)",
+                    currentServer->appInfo_.appUid, server->appInfo_.appUid);
+                currentServer->StopScreenCaptureByEvent(
+                    AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER);
+            }
         }
         activeSessionId.store(SESSION_ID_INVALID);
         int32_t ret = server->OnReceiveUserPrivacyAuthority(true);
         CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret,
             "ReportAVScreenCaptureUserChoice user choice is true but start failed");
         activeSessionId.store(sessionId);
-        MEDIA_LOGI("ScreenCaptureServer::ReportAVScreenCaptureUserChoice user choice is true and start success");
+        MEDIA_LOGI("ReportAVScreenCaptureUserChoice user choice is true and start success");
         return MSERR_OK;
     } else if (USER_CHOICE_DENY.compare(choice) == 0) {
         return server->OnReceiveUserPrivacyAuthority(false);
     }
-    MEDIA_LOGI("ScreenCaptureServer::ReportAVScreenCaptureUserChoice user choice is not support");
+    MEDIA_LOGW("ReportAVScreenCaptureUserChoice user choice is not support");
     return MSERR_UNKNOWN;
 }
 
@@ -156,8 +212,7 @@ ScreenCaptureServer::ScreenCaptureServer()
 ScreenCaptureServer::~ScreenCaptureServer()
 {
     MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
-    std::lock_guard<std::mutex> lock(mutex_);
-    StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID);
+    Release();
 }
 
 void ScreenCaptureServer::SetSessionId(int32_t sessionId)
@@ -705,6 +760,7 @@ void ScreenCaptureServer::PostStartScreenCapture(bool isSuccess)
         }
         BehaviorEventWriteForScreenCapture("start", "AVScreenCapture", appInfo_.appUid, appInfo_.appPid);
         captureState_ = AVScreenCaptureState::STARTED;
+        screenCaptureCb_->OnStateChange(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED);
     } else {
         MEDIA_LOGE("PostStartScreenCapture handle failure");
         isPrivacyAuthorityEnabled_ = false;
@@ -1083,7 +1139,7 @@ int32_t ScreenCaptureServer::StartHomeVideoCapture()
     std::string virtualScreenName = "screen_capture";
     if (isSurfaceMode_) {
         int32_t ret = CreateVirtualScreen(virtualScreenName, surface_);
-        CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, MSERR_UNKNOWN, "create virtual screen with input surface failed");
+        CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "create virtual screen with input surface failed");
         return MSERR_OK;
     }
 
@@ -1105,7 +1161,7 @@ int32_t ScreenCaptureServer::StartHomeVideoCapture()
     CHECK_AND_RETURN_RET_LOG(surfaceCb_ != nullptr, MSERR_UNKNOWN, "MakeSptr surfaceCb_ failed");
     consumer_->RegisterConsumerListener(surfaceCb_);
     int32_t ret = CreateVirtualScreen(virtualScreenName, producerSurface);
-    CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "CreateVirtualScreen failed");
+    CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "create virtual screen without input surface failed");
 
     CANCEL_SCOPE_EXIT_GUARD(0);
     return MSERR_OK;
@@ -1464,16 +1520,18 @@ int32_t ScreenCaptureServer::StopScreenCaptureInner(AVScreenCaptureStateCode sta
 int32_t ScreenCaptureServer::StopScreenCapture()
 {
     MediaTrace trace("ScreenCaptureServer::StopScreenCapture");
-    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances StopScreenCapture", FAKE_POINTER(this));
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances StopScreenCapture S", FAKE_POINTER(this));
 
     std::lock_guard<std::mutex> lock(mutex_);
-    return StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID);
+    int32_t ret = StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID);
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances StopScreenCapture E", FAKE_POINTER(this));
+    return ret;
 }
 
 void ScreenCaptureServer::Release()
 {
     MediaTrace trace("ScreenCaptureServer::Release");
-    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances Release", FAKE_POINTER(this));
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances Release S", FAKE_POINTER(this));
     int32_t sessionId;
     {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -1487,6 +1545,7 @@ void ScreenCaptureServer::Release()
 
     std::lock_guard<std::mutex> lock(mutex_);
     StopScreenCaptureInner(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID);
+    MEDIA_LOGI("0x%{public}06" PRIXPTR " Instances Release E", FAKE_POINTER(this));
 }
 
 void ScreenCapBufferConsumerListener::OnBufferAvailable()
diff --git a/test/unittest/resources/ohos_test.xml b/test/unittest/resources/ohos_test.xml
index 5f0bfd55d48422f2d321718dd6f2dacf0e52e122..4a77f635f21cec80cf95776ee8eb6523b53aa560 100644
--- a/test/unittest/resources/ohos_test.xml
+++ b/test/unittest/resources/ohos_test.xml
@@ -111,6 +111,30 @@
             <option name="shell" value="touch /data/test/media/screen_capture_check_param_07.mp4"/>
             <option name="shell" value="touch /data/test/media/screen_capture_with_surface_01.mp4"/>
             <option name="shell" value="touch /data/test/media/screen_capture_with_surface_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_03_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_03.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_04_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_04.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_05_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_05_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_06_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_07.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_save_file_cb_01.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_save_file_cb_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_02_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_03.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_03_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_04.mp4"/>
             <option name="shell" value="restorecon /data/test/media"/>
         </preparer>
     </target>
@@ -137,6 +161,30 @@
             <option name="shell" value="touch /data/test/media/screen_capture_check_param_07.mp4"/>
             <option name="shell" value="touch /data/test/media/screen_capture_with_surface_01.mp4"/>
             <option name="shell" value="touch /data/test/media/screen_capture_with_surface_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_01.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_02.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_03_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_03.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_04_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_04.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_05_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_05_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_06_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_specified_window_cb_07.yuv"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_save_file_cb_01.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_save_file_cb_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_01_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_02.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_02_inner.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_03.mp4"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_03_mic.pcm"/>
+            <option name="shell" value="touch /data/test/media/screen_capture_with_surface_cb_04.mp4"/>
             <option name="shell" value="restorecon /data/test/media"/>
         </preparer>
     </target>
diff --git a/test/unittest/screen_capture_test/BUILD.gn b/test/unittest/screen_capture_test/BUILD.gn
index cc43d8f07fd4c240b9b0e5743b8452be4c669aaa..50e3b14f7d3df569af745966616921f35174b65c 100644
--- a/test/unittest/screen_capture_test/BUILD.gn
+++ b/test/unittest/screen_capture_test/BUILD.gn
@@ -27,6 +27,12 @@ ohos_unittest("screen_capture_native_unit_test") {
     "$MEDIA_PLAYER_GRAPHIC_SURFACE/interfaces/inner_api/surface",
   ]
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   cflags = [
     "-Wall",
     "-Werror",
@@ -37,6 +43,7 @@ ohos_unittest("screen_capture_native_unit_test") {
       "native/screen_capture_mock_factory.cpp",
       "native/src/screen_capture_native_mock.cpp",
       "screen_capture_unittest/src/screen_capture_unit_test.cpp",
+      "screen_capture_unittest/src/screen_capture_unit_test_state.cpp",
     ]
   }
 
@@ -75,6 +82,12 @@ ohos_unittest("screen_capture_capi_unit_test") {
     "$MEDIA_PLAYER_GRAPHIC_SURFACE/interfaces/inner_api/surface",
   ]
 
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   cflags = [
     "-Wall",
     "-Werror",
@@ -85,6 +98,7 @@ ohos_unittest("screen_capture_capi_unit_test") {
       "capi/screen_capture_mock_factory.cpp",
       "capi/src/screen_capture_capi_mock.cpp",
       "screen_capture_unittest/src/screen_capture_unit_test.cpp",
+      "screen_capture_unittest/src/screen_capture_unit_test_state.cpp",
     ]
   }
 
@@ -103,6 +117,7 @@ ohos_unittest("screen_capture_capi_unit_test") {
     "c_utils:utils",
     "graphic_surface:surface",
     "hilog:libhilog",
+    "media_foundation:media_foundation",
     "player_framework:media_client",
     "window_manager:libdm",
   ]
diff --git a/test/unittest/screen_capture_test/capi/include/screen_capture_capi_mock.h b/test/unittest/screen_capture_test/capi/include/screen_capture_capi_mock.h
index ee63f65f46fb8e08149fd700a867fb6a1bf527ce..5b506bf8579111fee99362bf0f53d42603a2f92a 100644
--- a/test/unittest/screen_capture_test/capi/include/screen_capture_capi_mock.h
+++ b/test/unittest/screen_capture_test/capi/include/screen_capture_capi_mock.h
@@ -24,7 +24,9 @@ class ScreenCaptureCapiMock : public ScreenCaptureMock {
 public:
     explicit ScreenCaptureCapiMock(OH_AVScreenCapture* screencapture) : screenCapture_(screencapture) {}
     ~ScreenCaptureCapiMock() = default;
-    int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& cb) override;
+    int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback,
+        const bool isErrorCallBackEnabled, const bool isDataCallBackEnabled,
+        const bool isStateChangeCallBackEnabled) override;
     int32_t Init(AVScreenCaptureConfig config) override;
     int32_t StartScreenCapture() override;
     int32_t StartScreenCaptureWithSurface(const std::any& value) override;
@@ -39,7 +41,18 @@ public:
     sptr<OHOS::SurfaceBuffer> AcquireVideoBuffer(int32_t &fence, int64_t &timestamp, OHOS::Rect &damage) override;
     int32_t ReleaseAudioBuffer(OHOS::Media::AudioCaptureSourceType type) override;
     int32_t ReleaseVideoBuffer() override;
-
+    bool IsErrorCallBackEnabled() override
+    {
+        return isErrorCallBackEnabled_;
+    }
+    bool IsDataCallBackEnabled() override
+    {
+        return isDataCallBackEnabled_;
+    }
+    bool IsStateChangeCallBackEnabled() override
+    {
+        return isStateChangeCallBackEnabled_;
+    }
 private:
     static void SetScreenCaptureCallback(OH_AVScreenCapture *screencapture,
         std::shared_ptr<ScreenCaptureCallBackMock> cb);
@@ -48,15 +61,20 @@ private:
     static void OnError(OH_AVScreenCapture *screenCapture, int32_t errorCode);
     static void OnAudioBufferAvailable(OH_AVScreenCapture *screenCapture, bool isReady, OH_AudioCaptureSourceType type);
     static void OnVideoBufferAvailable(OH_AVScreenCapture *screenCapture, bool isReady);
+    static void OnErrorNew(OH_AVScreenCapture *screenCapture, int32_t errorCode, void *userData);
+    static void OnBufferAvailable(OH_AVScreenCapture *screenCapture, OH_AVBuffer *buffer,
+        OH_AVScreenCaptureBufferType bufferType, int64_t timestamp, void *userData);
+    static void OnStateChange(struct OH_AVScreenCapture *capture,
+        OH_AVScreenCaptureStateCode stateCode, void *userData);
     OH_AVScreenCaptureConfig Convert(AVScreenCaptureConfig config);
 
     static std::mutex mutex_;
     static std::map<OH_AVScreenCapture *, std::shared_ptr<ScreenCaptureCallBackMock>> mockCbMap_;
 
     OH_AVScreenCapture* screenCapture_ = nullptr;
-
-    std::atomic<bool> isExit_ { false };
-    AVScreenCaptureConfig config_;
+    bool isErrorCallBackEnabled_ = false;
+    bool isDataCallBackEnabled_ = false;
+    bool isStateChangeCallBackEnabled_ = false;
 };
 } // namespace Media
 } // namespace OHOS
diff --git a/test/unittest/screen_capture_test/capi/src/screen_capture_capi_mock.cpp b/test/unittest/screen_capture_test/capi/src/screen_capture_capi_mock.cpp
index 3ef9005319e45188d61551cdf13ee112712f4162..885ec01c690d8f2637dcdfcf1ab5369eb043192f 100644
--- a/test/unittest/screen_capture_test/capi/src/screen_capture_capi_mock.cpp
+++ b/test/unittest/screen_capture_test/capi/src/screen_capture_capi_mock.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "screen_capture_capi_mock.h"
+#include "native_mfmagic.h"
 #include "native_window.h"
 
 using namespace std;
@@ -51,25 +52,52 @@ void ScreenCaptureCapiMock::OnVideoBufferAvailable(OH_AVScreenCapture *screenCap
     }
 }
 
+void ScreenCaptureCapiMock::OnErrorNew(OH_AVScreenCapture *screenCapture, int32_t errorCode, void *userData)
+{
+    std::shared_ptr<ScreenCaptureCallBackMock> mockCb = GetCallback(screenCapture);
+    if (mockCb != nullptr) {
+        mockCb->OnError(errorCode, userData);
+    }
+}
+
+void ScreenCaptureCapiMock::OnBufferAvailable(OH_AVScreenCapture *screenCapture, OH_AVBuffer *buffer,
+    OH_AVScreenCaptureBufferType bufferType, int64_t timestamp, void *userData)
+{
+    UNITTEST_CHECK_AND_RETURN_LOG(buffer != nullptr, "OH_AVBuffer buffer == nullptr");
+    std::shared_ptr<ScreenCaptureCallBackMock> mockCb = GetCallback(screenCapture);
+    if (mockCb != nullptr) {
+        mockCb->OnBufferAvailable(buffer->buffer_, static_cast<AVScreenCaptureBufferType>(bufferType), timestamp);
+    }
+}
+
+void ScreenCaptureCapiMock::OnStateChange(OH_AVScreenCapture *screenCapture,
+    OH_AVScreenCaptureStateCode stateCode, void *userData)
+{
+    std::shared_ptr<ScreenCaptureCallBackMock> mockCb = GetCallback(screenCapture);
+    if (mockCb != nullptr) {
+        mockCb->OnStateChange(static_cast<AVScreenCaptureStateCode>(stateCode));
+    }
+}
+
 OH_AVScreenCaptureConfig ScreenCaptureCapiMock::Convert(AVScreenCaptureConfig config)
 {
-    OH_AVScreenCaptureConfig config_;
-    config_.captureMode = static_cast<OH_CaptureMode>(config.captureMode);
-    config_.dataType = static_cast<OH_DataType>(config.dataType);
-    config_.audioInfo.micCapInfo = {
+    OH_AVScreenCaptureConfig tempConfig;
+    tempConfig.captureMode = static_cast<OH_CaptureMode>(config.captureMode);
+    tempConfig.dataType = static_cast<OH_DataType>(config.dataType);
+    tempConfig.audioInfo.micCapInfo = {
         .audioSampleRate = config.audioInfo.micCapInfo.audioSampleRate,
         .audioChannels = config.audioInfo.micCapInfo.audioChannels,
         .audioSource = static_cast<OH_AudioCaptureSourceType>(config.audioInfo.micCapInfo.audioSource)
     };
-    config_.audioInfo.innerCapInfo = {
+    tempConfig.audioInfo.innerCapInfo = {
         .audioSampleRate = config.audioInfo.innerCapInfo.audioSampleRate,
         .audioChannels = config.audioInfo.innerCapInfo.audioChannels,
         .audioSource = static_cast<OH_AudioCaptureSourceType>(config.audioInfo.innerCapInfo.audioSource)
     };
-    config_.audioInfo.audioEncInfo.audioBitrate = config.audioInfo.audioEncInfo.audioBitrate;
-    config_.audioInfo.audioEncInfo.audioCodecformat =
+    tempConfig.audioInfo.audioEncInfo.audioBitrate = config.audioInfo.audioEncInfo.audioBitrate;
+    tempConfig.audioInfo.audioEncInfo.audioCodecformat =
         static_cast<OH_AudioCodecFormat>(config.audioInfo.audioEncInfo.audioCodecformat);
-    config_.videoInfo.videoCapInfo.displayId = config.videoInfo.videoCapInfo.displayId;
+    tempConfig.videoInfo.videoCapInfo.displayId = config.videoInfo.videoCapInfo.displayId;
     std::list<int32_t> taskIds = config.videoInfo.videoCapInfo.taskIDs;
     if (taskIds.size() > 0) {
         int32_t *taskIds_temp = static_cast<int*>(malloc(sizeof(int)));
@@ -77,29 +105,29 @@ OH_AVScreenCaptureConfig ScreenCaptureCapiMock::Convert(AVScreenCaptureConfig co
             *taskIds_temp = *its;
             taskIds_temp++;
         }
-        config_.videoInfo.videoCapInfo.missionIDs = taskIds_temp;
+        tempConfig.videoInfo.videoCapInfo.missionIDs = taskIds_temp;
     }
-    config_.videoInfo.videoCapInfo.missionIDsLen = taskIds.size();
-    config_.videoInfo.videoCapInfo.videoFrameWidth = config.videoInfo.videoCapInfo.videoFrameWidth;
-    config_.videoInfo.videoCapInfo.videoFrameHeight = config.videoInfo.videoCapInfo.videoFrameHeight;
-    config_.videoInfo.videoCapInfo.videoSource =
+    tempConfig.videoInfo.videoCapInfo.missionIDsLen = taskIds.size();
+    tempConfig.videoInfo.videoCapInfo.videoFrameWidth = config.videoInfo.videoCapInfo.videoFrameWidth;
+    tempConfig.videoInfo.videoCapInfo.videoFrameHeight = config.videoInfo.videoCapInfo.videoFrameHeight;
+    tempConfig.videoInfo.videoCapInfo.videoSource =
         static_cast<OH_VideoSourceType>(config.videoInfo.videoCapInfo.videoSource);
-    config_.videoInfo.videoEncInfo = {
+    tempConfig.videoInfo.videoEncInfo = {
         .videoCodec = static_cast<OH_VideoCodecFormat>(config.videoInfo.videoEncInfo.videoCodec),
         .videoBitrate = static_cast<OH_VideoCodecFormat>(config.videoInfo.videoEncInfo.videoBitrate),
         .videoFrameRate = static_cast<OH_VideoCodecFormat>(config.videoInfo.videoEncInfo.videoFrameRate)
     };
     std::string url = config.recorderInfo.url;
     if (!(url.empty())) {
-        config_.recorderInfo.url = const_cast<char *>(config.recorderInfo.url.c_str());
-        config_.recorderInfo.urlLen = config.recorderInfo.url.size();
+        tempConfig.recorderInfo.url = const_cast<char *>(config.recorderInfo.url.c_str());
+        tempConfig.recorderInfo.urlLen = config.recorderInfo.url.size();
     }
     if (config.recorderInfo.fileFormat == ContainerFormatType::CFT_MPEG_4A) {
-        config_.recorderInfo.fileFormat = OH_ContainerFormatType::CFT_MPEG_4A;
+        tempConfig.recorderInfo.fileFormat = OH_ContainerFormatType::CFT_MPEG_4A;
     } else if (config.recorderInfo.fileFormat == ContainerFormatType::CFT_MPEG_4) {
-        config_.recorderInfo.fileFormat = OH_ContainerFormatType::CFT_MPEG_4;
+        tempConfig.recorderInfo.fileFormat = OH_ContainerFormatType::CFT_MPEG_4;
     }
-    return config_;
+    return tempConfig;
 }
 
 std::shared_ptr<ScreenCaptureCallBackMock> ScreenCaptureCapiMock::GetCallback(OH_AVScreenCapture *screenCapture)
@@ -133,18 +161,52 @@ void ScreenCaptureCapiMock::SetScreenCaptureCallback(OH_AVScreenCapture *screenc
     mockCbMap_[screencapture] = cb;
 }
 
-int32_t ScreenCaptureCapiMock::SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& cb)
+int32_t ScreenCaptureCapiMock::SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback,
+    const bool isErrorCallBackEnabled, const bool isDataCallBackEnabled, const bool isStateChangeCallBackEnabled)
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
-    if (cb != nullptr) {
-        SetScreenCaptureCallback(screenCapture_, cb);
-        struct OH_AVScreenCaptureCallback callback;
-        callback.onError = ScreenCaptureCapiMock::OnError;
-        callback.onAudioBufferAvailable = ScreenCaptureCapiMock::OnAudioBufferAvailable;
-        callback.onVideoBufferAvailable = ScreenCaptureCapiMock::OnVideoBufferAvailable;
-        return OH_AVScreenCapture_SetCallback(screenCapture_, callback);
+    if (callback == nullptr) {
+        return MSERR_INVALID_OPERATION;
+    }
+    MEDIA_LOGD("ScreenCaptureCapiMock SetScreenCaptureCallback");
+    SetScreenCaptureCallback(screenCapture_, callback);
+    struct OH_AVScreenCaptureCallback ohCallback;
+    ohCallback.onError = ScreenCaptureCapiMock::OnError;
+    ohCallback.onAudioBufferAvailable = ScreenCaptureCapiMock::OnAudioBufferAvailable;
+    ohCallback.onVideoBufferAvailable = ScreenCaptureCapiMock::OnVideoBufferAvailable;
+    int ret = OH_AVScreenCapture_SetCallback(screenCapture_, ohCallback);
+    if (ret != AV_SCREEN_CAPTURE_ERR_OK) {
+        MEDIA_LOGE("ScreenCaptureCapiMock SetCallback failed, ret: %{public}d", ret);
+        return MSERR_UNKNOWN;
+    }
+    if (isErrorCallBackEnabled) {
+        MEDIA_LOGD("ScreenCaptureCapiMock SetErrorCallback");
+        isErrorCallBackEnabled_ = isErrorCallBackEnabled;
+        ret = OH_AVScreenCapture_SetErrorCallback(screenCapture_, ScreenCaptureCapiMock::OnErrorNew, this);
+        if (ret != AV_SCREEN_CAPTURE_ERR_OK) {
+            MEDIA_LOGE("ScreenCaptureCapiMock SetErrorCallback failed, ret: %{public}d", ret);
+            return MSERR_UNKNOWN;
+        }
+    }
+    if (isDataCallBackEnabled) {
+        MEDIA_LOGD("ScreenCaptureCapiMock SetDataCallback");
+        isDataCallBackEnabled_ = isDataCallBackEnabled;
+        ret = OH_AVScreenCapture_SetDataCallback(screenCapture_, ScreenCaptureCapiMock::OnBufferAvailable, this);
+        if (ret != AV_SCREEN_CAPTURE_ERR_OK) {
+            MEDIA_LOGE("ScreenCaptureCapiMock SetDataCallback failed, ret: %{public}d", ret);
+            return MSERR_UNKNOWN;
+        }
+    }
+    if (isStateChangeCallBackEnabled) {
+        MEDIA_LOGD("ScreenCaptureCapiMock SetStateCallback");
+        isStateChangeCallBackEnabled_ = isStateChangeCallBackEnabled;
+        ret = OH_AVScreenCapture_SetStateCallback(screenCapture_, ScreenCaptureCapiMock::OnStateChange, this);
+        if (ret != AV_SCREEN_CAPTURE_ERR_OK) {
+            MEDIA_LOGE("ScreenCaptureCapiMock SetStateCallback failed, ret: %{public}d", ret);
+            return MSERR_UNKNOWN;
+        }
     }
-    return MSERR_INVALID_OPERATION;
+    return MSERR_OK;
 }
 
 int32_t ScreenCaptureCapiMock::StartScreenCapture()
@@ -165,8 +227,8 @@ int32_t ScreenCaptureCapiMock::StartScreenCaptureWithSurface(const std::any& val
 int32_t ScreenCaptureCapiMock::Init(AVScreenCaptureConfig config)
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
-    OH_AVScreenCaptureConfig config_ = Convert(config);
-    return OH_AVScreenCapture_Init(screenCapture_, config_);
+    OH_AVScreenCaptureConfig tempConfig = Convert(config);
+    return OH_AVScreenCapture_Init(screenCapture_, tempConfig);
 }
 
 int32_t ScreenCaptureCapiMock::StopScreenCapture()
diff --git a/test/unittest/screen_capture_test/native/include/screen_capture_native_mock.h b/test/unittest/screen_capture_test/native/include/screen_capture_native_mock.h
index 88f016ca41aa131666ed85ca66f16b50cf50ac45..c0f504e709fcea89adfed72df9d67127b9af15e5 100644
--- a/test/unittest/screen_capture_test/native/include/screen_capture_native_mock.h
+++ b/test/unittest/screen_capture_test/native/include/screen_capture_native_mock.h
@@ -24,7 +24,9 @@ class ScreenCaptureNativeMock : public ScreenCaptureMock {
 public:
     explicit ScreenCaptureNativeMock(std::shared_ptr<ScreenCapture> screencapture) : screenCapture_(screencapture) {}
     ~ScreenCaptureNativeMock();
-    int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback) override;
+    int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback,
+        const bool isErrorCallBackEnabled, const bool isDataCallBackEnabled,
+        const bool isStateChangeCallBackEnabled) override;
     int32_t Init(AVScreenCaptureConfig config) override;
     int32_t StartScreenCapture() override;
     int32_t StartScreenCaptureWithSurface(const std::any& value) override;
@@ -38,11 +40,14 @@ public:
     sptr<OHOS::SurfaceBuffer> AcquireVideoBuffer(int32_t &fence, int64_t &timestamp, OHOS::Rect &damage) override;
     int32_t ReleaseAudioBuffer(AudioCaptureSourceType type) override;
     int32_t ReleaseVideoBuffer() override;
-
+    bool IsStateChangeCallBackEnabled() override
+    {
+        return isStateChangeCallBackEnabled_;
+    }
 private:
     std::shared_ptr<ScreenCapture> screenCapture_ = nullptr;
-    std::shared_ptr<ScreenCaptureNativeCallbackMock> cb_;
-    AVScreenCaptureConfig config_;
+    std::shared_ptr<ScreenCaptureCallBack> cb_;
+    bool isStateChangeCallBackEnabled_ = false;
 };
 
 class ScreenCaptureNativeCallbackMock : public ScreenCaptureCallBack, public NoCopyable {
@@ -56,6 +61,7 @@ public:
     void OnError(ScreenCaptureErrorType errorType, int32_t errorCode) override;
     void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type) override;
     void OnVideoBufferAvailable(bool isReady) override;
+    void OnStateChange(AVScreenCaptureStateCode stateCode) override;
     void OnRelease();
 
 private:
diff --git a/test/unittest/screen_capture_test/native/src/screen_capture_native_mock.cpp b/test/unittest/screen_capture_test/native/src/screen_capture_native_mock.cpp
index 80ce8cecd28795f740ba441bd8d3c19e613bfea9..b6458d0e71592936990468418345436f8aa7606b 100644
--- a/test/unittest/screen_capture_test/native/src/screen_capture_native_mock.cpp
+++ b/test/unittest/screen_capture_test/native/src/screen_capture_native_mock.cpp
@@ -48,6 +48,14 @@ void ScreenCaptureNativeCallbackMock::OnVideoBufferAvailable(bool isReady)
     }
 }
 
+void ScreenCaptureNativeCallbackMock::OnStateChange(AVScreenCaptureStateCode stateCode)
+{
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (mockCb_ != nullptr) {
+        mockCb_->OnStateChange(stateCode);
+    }
+}
+
 void ScreenCaptureNativeCallbackMock::OnRelease()
 {
     std::unique_lock<std::mutex> lock(mutex_);
@@ -59,9 +67,13 @@ ScreenCaptureNativeMock::~ScreenCaptureNativeMock()
     MEDIA_LOGI("ScreenCaptureNativeMock::~ScreenCaptureNativeMock");
 }
 
-int32_t ScreenCaptureNativeMock::SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback)
+int32_t ScreenCaptureNativeMock::SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback,
+    const bool isErrorCallBackEnabled, const bool isDataCallBackEnabled, const bool isStateChangeCallBackEnabled)
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
+    (void)isErrorCallBackEnabled; // Inner is not support to set New ErrorCallBack
+    (void)isDataCallBackEnabled; // Inner is not support to set New DataCallBack
+    isStateChangeCallBackEnabled_ = isStateChangeCallBackEnabled;
     if (callback != nullptr) {
         cb_ = std::make_shared<ScreenCaptureNativeCallbackMock>(callback, screenCapture_);
         return screenCapture_->SetScreenCaptureCallback(cb_);
@@ -72,12 +84,20 @@ int32_t ScreenCaptureNativeMock::SetScreenCaptureCallback(const std::shared_ptr<
 int32_t ScreenCaptureNativeMock::StartScreenCapture()
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
+    if (isStateChangeCallBackEnabled_) {
+        int32_t ret = screenCapture_->SetPrivacyAuthorityEnabled();
+        UNITTEST_CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPrivacyAuthorityEnabled failed");
+    }
     return screenCapture_->StartScreenCapture();
 }
 
 int32_t ScreenCaptureNativeMock::StartScreenCaptureWithSurface(const std::any& value)
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
+    if (isStateChangeCallBackEnabled_) {
+        int32_t ret = screenCapture_->SetPrivacyAuthorityEnabled();
+        UNITTEST_CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPrivacyAuthorityEnabled failed");
+    }
     sptr<Surface> surface = std::any_cast<sptr<Surface>>(value);
     return screenCapture_->StartScreenCaptureWithSurface(surface);
 }
@@ -97,6 +117,10 @@ int32_t ScreenCaptureNativeMock::StopScreenCapture()
 int32_t ScreenCaptureNativeMock::StartScreenRecording()
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
+    if (isStateChangeCallBackEnabled_) {
+        int32_t ret = screenCapture_->SetPrivacyAuthorityEnabled();
+        UNITTEST_CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetPrivacyAuthorityEnabled failed");
+    }
     return screenCapture_->StartScreenRecording();
 }
 
@@ -109,8 +133,10 @@ int32_t ScreenCaptureNativeMock::StopScreenRecording()
 int32_t ScreenCaptureNativeMock::Release()
 {
     UNITTEST_CHECK_AND_RETURN_RET_LOG(screenCapture_ != nullptr, MSERR_INVALID_OPERATION, "screenCapture_ == nullptr");
-    if (cb_ != nullptr) {
-        cb_->OnRelease();
+    std::shared_ptr<ScreenCaptureCallBack> cb = cb_;
+    ScreenCaptureNativeCallbackMock *callback = static_cast<ScreenCaptureNativeCallbackMock *>(cb.get());
+    if (callback != nullptr) {
+        callback->OnRelease();
         cb_ = nullptr;
     }
     return screenCapture_->Release();
diff --git a/test/unittest/screen_capture_test/screen_capture_mock.h b/test/unittest/screen_capture_test/screen_capture_mock.h
index b713aaabfd04443fd0c89f0922d159bc992df054..435a7db2b5d5a737d505d3a89327b8d49e93972f 100644
--- a/test/unittest/screen_capture_test/screen_capture_mock.h
+++ b/test/unittest/screen_capture_test/screen_capture_mock.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <thread>
 #include <cstdio>
+#include "avbuffer.h"
 #include "gtest/gtest.h"
 #include "screen_capture.h"
 #include "unittest_log.h"
@@ -41,12 +42,22 @@ public:
     virtual void OnError(int32_t errorCode) = 0;
     virtual void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type) = 0;
     virtual void OnVideoBufferAvailable(bool isReady) = 0;
+    virtual void OnStateChange(AVScreenCaptureStateCode stateCode) = 0;
+    virtual void OnError(int32_t errorCode, void *userData)
+    {
+        (void)errorCode;
+        (void)userData;
+    }
+    virtual void OnBufferAvailable(const std::shared_ptr<AVBuffer> buffer,
+        AVScreenCaptureBufferType bufferType, int64_t timestamp) = 0;
 };
 
 class ScreenCaptureMock {
 public:
     virtual ~ScreenCaptureMock() = default;
-    virtual int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback) = 0;
+    virtual int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBackMock>& callback,
+        const bool isErrorCallBackEnabled = false, const bool isDataCallBackEnabled = false,
+        const bool isStateChangeCallBackEnabled = false) = 0;
     virtual int32_t Init(AVScreenCaptureConfig config) = 0;
     virtual int32_t StartScreenCapture() = 0;
     virtual int32_t StartScreenCaptureWithSurface(const std::any& value) = 0;
@@ -60,6 +71,18 @@ public:
     virtual sptr<OHOS::SurfaceBuffer> AcquireVideoBuffer(int32_t &fence, int64_t &timestamp, OHOS::Rect &damage) = 0;
     virtual int32_t ReleaseAudioBuffer(AudioCaptureSourceType type) = 0;
     virtual int32_t ReleaseVideoBuffer() = 0;
+    virtual bool IsErrorCallBackEnabled()
+    {
+        return false;
+    }
+    virtual bool IsDataCallBackEnabled()
+    {
+        return false;
+    }
+    virtual bool IsStateChangeCallBackEnabled()
+    {
+        return false;
+    }
 };
 
 class __attribute__((visibility("default"))) ScreenCaptureMockFactory {
diff --git a/test/unittest/screen_capture_test/screen_capture_unittest/include/screen_capture_unit_test.h b/test/unittest/screen_capture_test/screen_capture_unittest/include/screen_capture_unit_test.h
index 2672f78598325aeaf6612e74082d2e1c0d291f09..0b3be6ac5590c5215cc87131754993457a89addd 100644
--- a/test/unittest/screen_capture_test/screen_capture_unittest/include/screen_capture_unit_test.h
+++ b/test/unittest/screen_capture_test/screen_capture_unittest/include/screen_capture_unit_test.h
@@ -25,14 +25,40 @@ public:
     explicit ScreenCaptureUnitTestCallback(std::shared_ptr<ScreenCaptureMock> ScreenCapture, FILE *aFile, FILE *vFile,
         int32_t aFlag, int32_t vFlag)
         : screenCapture_(ScreenCapture), aFile_(aFile), vFile_(vFile), aFlag_(aFlag), vFlag_(vFlag) {}
+    explicit ScreenCaptureUnitTestCallback(std::shared_ptr<ScreenCaptureMock> ScreenCapture)
+        : screenCapture_(ScreenCapture) {}
     ~ScreenCaptureUnitTestCallback() = default;
     void OnError(int32_t errorCode) override;
     void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type) override;
     void OnVideoBufferAvailable(bool isReady) override;
+    void OnStateChange(AVScreenCaptureStateCode stateCode) override;
+    void OnError(int32_t errorCode, void *userData) override;
+    void OnBufferAvailable(std::shared_ptr<AVBuffer> buffer, AVScreenCaptureBufferType bufferType,
+        int64_t timestamp) override;
+    void ProcessAudioBuffer(uint8_t *buffer, int32_t size, int64_t timestamp, AVScreenCaptureBufferType bufferType);
+    void ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp);
+    void CheckDataCallbackAudio(AudioCaptureSourceType type, int32_t flag);
+    void CheckDataCallbackVideo(int32_t flag);
+    void DumpBuffer(FILE *file, uint8_t *buffer, int32_t size, int64_t timestamp,
+        AVScreenCaptureBufferType bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    void InitCaptureTrackInfo(FILE *file, int32_t flag, AVScreenCaptureBufferType bufferType);
+    AVScreenCaptureStateCode GetScreenCaptureState()
+    {
+        return screenCaptureState_.load();
+    }
     void DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer);
-    void DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer);
+    void DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp);
+
 private:
     std::shared_ptr<ScreenCaptureMock> screenCapture_;
+    FILE *innerAudioFile_ = nullptr;
+    FILE *micAudioFile_ = nullptr;
+    FILE *videoFile_ = nullptr;
+    int32_t innerAudioFlag_ = 0;
+    int32_t micAudioFlag_ = 0;
+    int32_t videoFlag_ = 0;
+    std::atomic<AVScreenCaptureStateCode> screenCaptureState_ = AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INVLID;
+
     FILE *aFile_ = nullptr;
     FILE *vFile_ = nullptr;
     int32_t aFlag_ = 0;
@@ -49,19 +75,29 @@ public:
     void AudioLoopWithoutRelease(void);
     int32_t SetConfig(AVScreenCaptureConfig &config);
     int32_t SetConfigFile(AVScreenCaptureConfig &config, RecorderInfo &recorderInfo);
-    int32_t SetRecorderInfo(std::string filename, RecorderInfo &recorderInfo);
-    void OpenFile(std::string filename_);
+    int32_t SetRecorderInfo(std::string name, RecorderInfo &recorderInfo);
+    void OpenFile(std::string name);
     void CloseFile(void);
-    char filename[100] = {0};
-    FILE *aFile = nullptr;
-    FILE *vFile = nullptr;
-    int32_t aFlag = 0;
-    int32_t vFlag = 0;
+    void OpenFile(std::string name, bool isInnerAudioEnabled, bool isMicAudioEnabled, bool isVideoEnabled);
+    void OpenFileFd(std::string name);
+
 protected:
+    static const std::string SCREEN_CAPTURE_ROOT_DIR;
+
     std::shared_ptr<ScreenCaptureMock> screenCapture_ = nullptr;
     std::shared_ptr<ScreenCaptureUnitTestCallback> screenCaptureCb_ = nullptr;
     std::unique_ptr<std::thread> audioLoop_ = nullptr;
-    const std::string screenCaptureRoot = "/data/test/media/";
+
+    AVScreenCaptureConfig config_;
+    FILE *aFile = nullptr;
+    FILE *vFile = nullptr;
+    int32_t aFlag = 0;
+    int32_t vFlag = 0;
+    char fileName[100] = {0};
+    FILE *innerAudioFile_ = nullptr;
+    FILE *micAudioFile_ = nullptr;
+    FILE *videoFile_ = nullptr;
+    int32_t outputFd_ = -1;
 };
 } // namespace Media
 } // namespace OHOS
diff --git a/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp
index 0b617154e53ba03b28b27161150c0387e4123a1b..ac36509ba12c7db9f0b66494a2201a3c09b4eab2 100644
--- a/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp
+++ b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test.cpp
@@ -31,278 +31,6 @@ using namespace OHOS::Media::ScreenCaptureTestParam;
 
 namespace OHOS {
 namespace Media {
-void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode)
-{
-    cout << "Error received, errorCode:" << errorCode << endl;
-}
-
-void ScreenCaptureUnitTestCallback::OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type)
-{
-    if (isReady) {
-        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
-        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
-            if (audioBuffer == nullptr) {
-                cout << "AcquireAudioBuffer failed, audio buffer empty, PLEASE CHECK IF IT IS OK!!!" << endl;
-            } else {
-                cout << "AcquireAudioBuffer, audioBufferLen:" << audioBuffer->length << ", timestampe:"
-                    << audioBuffer->timestamp << ", audioSourceType:" << audioBuffer->sourcetype << endl;
-                DumpAudioBuffer(audioBuffer);
-            }
-        }
-        if (aFlag_ == 1) {
-            screenCapture_->ReleaseAudioBuffer(type);
-        }
-    } else {
-        cout << "AcquireAudioBuffer failed" << endl;
-    }
-}
-
-void ScreenCaptureUnitTestCallback::DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)
-{
-    if ((aFile_ != nullptr) && (audioBuffer->buffer != nullptr)) {
-        if (fwrite(audioBuffer->buffer, 1, audioBuffer->length, aFile_) != static_cast<size_t>(audioBuffer->length)) {
-            cout << "error occurred in fwrite:" << strerror(errno) <<endl;
-        }
-    }
-}
-
-void ScreenCaptureUnitTestCallback::OnVideoBufferAvailable(bool isReady)
-{
-    if (isReady) {
-        int32_t fence = 0;
-        int64_t timestamp = 0;
-        OHOS::Rect damage;
-        sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
-        if (surfacebuffer != nullptr) {
-            int32_t length = surfacebuffer->GetSize();
-            cout << "AcquireVideoBuffer, videoBufferLen:" << surfacebuffer->GetSize() << ", timestamp:"
-                << timestamp << ", size:"<< length << endl;
-            DumpVideoBuffer(surfacebuffer);
-            if (vFlag_ == 1) {
-                screenCapture_->ReleaseVideoBuffer();
-            }
-        } else {
-            cout << "AcquireVideoBuffer failed" << endl;
-        }
-    }
-}
-
-void ScreenCaptureUnitTestCallback::DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer)
-{
-    if (vFile_ != nullptr) {
-        if (fwrite(surfacebuffer->GetVirAddr(), 1, surfacebuffer->GetSize(), vFile_) != surfacebuffer->GetSize()) {
-            cout << "error occurred in fwrite:" << strerror(errno) <<endl;
-        }
-    }
-}
-
-void ScreenCaptureUnitTest::SetUpTestCase(void) {}
-
-void ScreenCaptureUnitTest::TearDownTestCase(void) {}
-
-void ScreenCaptureUnitTest::SetUp(void)
-{
-    screenCapture_ = ScreenCaptureMockFactory::CreateScreenCapture();
-    ASSERT_NE(nullptr, screenCapture_);
-}
-
-void ScreenCaptureUnitTest::TearDown(void)
-{
-    if (screenCaptureCb_ != nullptr) {
-        screenCaptureCb_.reset();
-        screenCaptureCb_ = nullptr;
-    }
-    if (screenCapture_ != nullptr) {
-        screenCapture_->Release();
-        screenCapture_ = nullptr;
-    }
-}
-
-int32_t ScreenCaptureUnitTest::SetConfig(AVScreenCaptureConfig &config)
-{
-    AudioCaptureInfo miccapinfo = {
-        .audioSampleRate = 16000,
-        .audioChannels = 2,
-        .audioSource = SOURCE_DEFAULT
-    };
-
-    VideoCaptureInfo videocapinfo = {
-        .videoFrameWidth = 720,
-        .videoFrameHeight = 1280,
-        .videoSource = VIDEO_SOURCE_SURFACE_RGBA
-    };
-
-    VideoEncInfo videoEncInfo = {
-        .videoCodec = VideoCodecFormat::H264,
-        .videoBitrate = 2000000,
-        .videoFrameRate = 30
-    };
-
-    AudioInfo audioinfo = {
-        .micCapInfo = miccapinfo,
-    };
-
-    VideoInfo videoinfo = {
-        .videoCapInfo = videocapinfo,
-        .videoEncInfo = videoEncInfo
-    };
-
-    config = {
-        .captureMode = CAPTURE_HOME_SCREEN,
-        .dataType = ORIGINAL_STREAM,
-        .audioInfo = audioinfo,
-        .videoInfo = videoinfo
-    };
-    return MSERR_OK;
-}
-
-int32_t ScreenCaptureUnitTest::SetConfigFile(AVScreenCaptureConfig &config, RecorderInfo &recorderInfo)
-{
-    AudioEncInfo audioEncInfo = {
-        .audioBitrate = 48000,
-        .audioCodecformat = AudioCodecFormat::AAC_LC
-    };
-
-    VideoCaptureInfo videoCapInfo = {
-        .videoFrameWidth = 720,
-        .videoFrameHeight = 1080,
-        .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
-    };
-
-    VideoEncInfo videoEncInfo = {
-        .videoCodec = VideoCodecFormat::H264,
-        .videoBitrate = 2000000,
-        .videoFrameRate = 30
-    };
-
-    AudioCaptureInfo innerCapInfo = {
-        .audioSampleRate = 0,
-        .audioChannels = 0,
-        .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
-    };
-
-    AudioCaptureInfo micCapInfo = {
-        .audioSampleRate = 0,
-        .audioChannels = 0,
-        .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
-    };
-
-    AudioInfo audioInfo = {
-        .micCapInfo = micCapInfo,
-        .innerCapInfo = innerCapInfo,
-        .audioEncInfo = audioEncInfo
-    };
-
-    VideoInfo videoInfo = {
-        .videoCapInfo = videoCapInfo,
-        .videoEncInfo = videoEncInfo
-    };
-
-    config = {
-        .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
-        .dataType = DataType::CAPTURE_FILE,
-        .audioInfo = audioInfo,
-        .videoInfo = videoInfo,
-        .recorderInfo = recorderInfo
-    };
-    return MSERR_OK;
-}
-
-int32_t ScreenCaptureUnitTest::SetRecorderInfo(std::string filename, RecorderInfo &recorderInfo)
-{
-    int32_t outputFd = open((screenCaptureRoot + filename).c_str(), O_RDWR | O_CREAT, 0777);
-    recorderInfo.url = "fd://" + to_string(outputFd);
-    recorderInfo.fileFormat = "mp4";
-    return MSERR_OK;
-}
-
-void ScreenCaptureUnitTest::OpenFile(std::string filename_)
-{
-    if (snprintf_s(filename, sizeof(filename), sizeof(filename) - 1, "/data/test/media/%s.pcm",
-        filename_.c_str()) >= 0) {
-        aFile = fopen(filename, "w+");
-        if (aFile == nullptr) {
-            cout << "aFile audio open failed, " << strerror(errno) << endl;
-        }
-    } else {
-        cout << "snprintf audio file failed, " << strerror(errno) << endl;
-        return;
-    }
-    if (snprintf_s(filename, sizeof(filename), sizeof(filename) - 1, "/data/test/media/%s.yuv",
-        filename_.c_str()) >= 0) {
-        vFile = fopen(filename, "w+");
-        if (vFile == nullptr) {
-            cout << "vFile video open failed, " << strerror(errno) << endl;
-        }
-    } else {
-        cout << "snprintf video file failed, " << strerror(errno) << endl;
-        return;
-    }
-}
-
-void ScreenCaptureUnitTest::CloseFile(void)
-{
-    if (aFile != nullptr) {
-        fclose(aFile);
-        aFile = nullptr;
-    }
-    if (vFile != nullptr) {
-        fclose(vFile);
-        vFile = nullptr;
-    }
-}
-
-void ScreenCaptureUnitTest::AudioLoop(void)
-{
-    int index_ = 200;
-    int index_audio_frame = 0;
-    while (index_) {
-        if (screenCapture_ == nullptr) {
-            break;
-        }
-        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
-        AudioCaptureSourceType type = MIC;
-        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
-            if (audioBuffer == nullptr) {
-                cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
-                continue;
-            }
-            cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:"
-                << audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:"
-                << audioBuffer->sourcetype << endl;
-            screenCapture_->ReleaseAudioBuffer(type);
-        } else {
-            cout << "AcquireAudioBuffer failed" << endl;
-        }
-        index_--;
-    }
-}
-
-void ScreenCaptureUnitTest::AudioLoopWithoutRelease(void)
-{
-    int index_ = 200;
-    int index_audio_frame = 0;
-    while (index_) {
-        if (screenCapture_ == nullptr) {
-            break;
-        }
-        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
-        AudioCaptureSourceType type = MIC;
-        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
-            if (audioBuffer == nullptr) {
-                cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
-                continue;
-            }
-            cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:"
-                << audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:"
-                << audioBuffer->sourcetype << endl;
-        } else {
-            cout << "AcquireAudioBuffer failed" << endl;
-        }
-        index_--;
-    }
-}
-
 /**
  * @tc.name: screen_capture_specified_window_file_01
  * @tc.desc: do screencapture
@@ -315,7 +43,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_01, TestSiz
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_specified_window_file_01.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -360,7 +87,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_02, TestSiz
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_specified_window_file_02.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -405,7 +131,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_03, TestSiz
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_specified_window_file_03.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -450,7 +175,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_04, TestSiz
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_specified_window_file_04.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -493,7 +217,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window, TestSize.Level2
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
@@ -537,7 +260,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_Rotation, TestSi
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
@@ -581,7 +303,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_Rotation, TestSi
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_01, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_01 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_01.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -609,7 +330,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_01, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_02, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_02 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_02.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -662,7 +382,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_02, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_03, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_03 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_03.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -696,18 +415,17 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_03, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_04, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_04 before");
-    AVScreenCaptureConfig config;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_04.mp4", recorderInfo);
-    SetConfigFile(config, recorderInfo);
+    SetConfigFile(config_, recorderInfo);
     AudioCaptureInfo innerCapInfo = {
         .audioSampleRate = 16000,
         .audioChannels = 2,
         .audioSource = AudioCaptureSourceType::APP_PLAYBACK
     };
-    config.audioInfo.innerCapInfo = innerCapInfo;
+    config_.audioInfo.innerCapInfo = innerCapInfo;
 
-    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config));
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
     EXPECT_NE(MSERR_OK, screenCapture_->StartScreenCapture());
     sleep(RECORDER_TIME);
     EXPECT_NE(MSERR_OK, screenCapture_->StopScreenCapture());
@@ -724,9 +442,8 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_04, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_05, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_05 before");
-    AVScreenCaptureConfig config;
-    SetConfig(config);
-    config.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
+    SetConfig(config_);
+    config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     OpenFile("screen_capture_get_screen_capture_05");
 
     aFlag = 1;
@@ -736,7 +453,7 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_05, TestSize.Level2)
     bool isMicrophone = true;
     screenCapture_->SetMicrophoneEnabled(isMicrophone);
     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
-    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config));
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
     EXPECT_NE(MSERR_OK, screenCapture_->StartScreenRecording());
     sleep(RECORDER_TIME);
     EXPECT_NE(MSERR_OK, screenCapture_->StopScreenRecording());
@@ -754,9 +471,8 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_05, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation before");
-    AVScreenCaptureConfig config;
-    SetConfig(config);
-    config.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
+    SetConfig(config_);
+    config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     OpenFile("screen_capture_save_file_Rotation");
 
     aFlag = 1;
@@ -768,7 +484,7 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation, TestSize.Leve
     bool canvasRotation = true;
     EXPECT_NE(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation));
     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_));
-    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config));
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
     EXPECT_NE(MSERR_OK, screenCapture_->StartScreenRecording());
     sleep(RECORDER_TIME);
     EXPECT_NE(MSERR_OK, screenCapture_->StopScreenRecording());
@@ -786,7 +502,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation, TestSize.Leve
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_01, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_01 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_Rotation_01.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -825,7 +540,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_01, TestSize.L
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_02, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_02 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_Rotation_02.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -858,7 +572,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_02, TestSize.L
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_03, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_03 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_Rotation_03.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -891,7 +604,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_03, TestSize.L
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_01, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_01 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_specified_screen_file_01.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -928,7 +640,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_01, TestSiz
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_02, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_02 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_02.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -968,7 +679,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_02, TestSiz
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_03, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_03 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_get_screen_capture_03.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1010,7 +720,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_03, TestSiz
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_01, TestSize.Level1)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     std::vector<sptr<Screen>> screens;
@@ -1043,7 +752,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_01, TestSize.Lev
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_01, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_01 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1094,7 +802,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_01, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_02, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_02 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1134,7 +841,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_02, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_03, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_03 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1176,7 +882,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_03, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_04, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_04 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1228,7 +933,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_04, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_05, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_05 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1264,11 +968,8 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_05, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_06, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_06 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
-    int32_t outputFd = open((screenCaptureRoot + "screen_capture_check_param_06.mp4").c_str(),
-        O_RDWR | O_CREAT, 0777);
-    recorderInfo.url = "fd://" + to_string(outputFd);
+    SetRecorderInfo("screen_capture_check_param_06.mp4", recorderInfo);
     recorderInfo.fileFormat = "avi";
     SetConfigFile(config_, recorderInfo);
     AudioCaptureInfo innerCapInfo = {
@@ -1292,7 +993,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_06, TestSize.Level2)
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_07, TestSize.Level2)
 {
     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_07 before");
-    AVScreenCaptureConfig config_;
     RecorderInfo recorderInfo;
     SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo);
     SetConfigFile(config_, recorderInfo);
@@ -1333,7 +1033,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_07, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1352,7 +1051,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0001, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1371,7 +1069,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0002, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0003, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV;
 
@@ -1389,7 +1086,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0003, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0004, TestSize.Level0)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_ES;
 
@@ -1407,7 +1103,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0004, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_without_audio_data, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     OpenFile("screen_capture_without_audio_data");
@@ -1435,7 +1130,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_without_audio_data, TestSize.Leve
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.audioInfo.micCapInfo.audioSampleRate = -1;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1454,7 +1148,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0001, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.audioInfo.micCapInfo.audioChannels = -1;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1473,7 +1166,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0002, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0003, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1492,7 +1184,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0003, TestSize.Le
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_avconfigure, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV;
@@ -1511,7 +1202,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_avconfigure, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_audio_data, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     OpenFile("screen_capture_with_audio_data");
@@ -1539,7 +1229,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_audio_data, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.captureMode = static_cast<CaptureMode>(-1);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1558,7 +1247,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0001, TestSize.Level2
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.captureMode = static_cast<CaptureMode>(5);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1577,7 +1265,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0002, TestSize.Level2
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     config_.dataType = ENCODED_STREAM;
@@ -1596,7 +1283,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0001, TestSize.Leve
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     config_.dataType = CAPTURE_FILE;
@@ -1615,7 +1301,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0002, TestSize.Leve
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0003, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     config_.dataType = INVAILD;
@@ -1634,7 +1319,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0003, TestSize.Leve
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audioSampleRate_48000, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.audioInfo.micCapInfo.audioSampleRate = 48000;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
@@ -1661,12 +1345,13 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_audioSampleRate_48000, TestSize.L
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = 160;
     config_.videoInfo.videoCapInfo.videoFrameHeight = 160;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
-    vFile = fopen("/data/screen_capture/screen_capture_video_size_0001.yuv", "w+");
+
+    std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0001.yuv";
+    vFile = fopen(name.c_str(), "w+");
     if (vFile == nullptr) {
         cout << "vFile video open failed, " << strerror(errno) << endl;
     }
@@ -1694,12 +1379,13 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0001, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = 640;
     config_.videoInfo.videoCapInfo.videoFrameHeight = 480;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
-    vFile = fopen("/data/screen_capture/screen_capture_video_size_0002.yuv", "w+");
+
+    std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0002.yuv";
+    vFile = fopen(name.c_str(), "w+");
     if (vFile == nullptr) {
         cout << "vFile video open failed, " << strerror(errno) << endl;
     }
@@ -1727,12 +1413,13 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0002, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0003, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = 1920;
     config_.videoInfo.videoCapInfo.videoFrameHeight = 1080;
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
-    vFile = fopen("/data/screen_capture/screen_capture_video_size_0003.yuv", "w+");
+
+    std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0003.yuv";
+    vFile = fopen(name.c_str(), "w+");
     if (vFile == nullptr) {
         cout << "vFile video open failed, " << strerror(errno) << endl;
     }
@@ -1760,14 +1447,13 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0003, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_from_display, TestSize.Level0)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
     sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync();
     ASSERT_NE(display, nullptr);
     cout << "get displayinfo: " << endl;
-    cout << "width: " << display->GetWidth() << "; height: " << display->GetHeight() << "; density: "
-        << display->GetDpi() << "; refreshRate: " << display->GetRefreshRate() << endl;
+    cout << "width: " << display->GetWidth() << "; height: " << display->GetHeight() << "; density: " <<
+        display->GetDpi() << "; refreshRate: " << display->GetRefreshRate() << endl;
 
     config_.videoInfo.videoCapInfo.videoFrameWidth = display->GetWidth();
     config_.videoInfo.videoCapInfo.videoFrameHeight = display->GetHeight();
@@ -1794,7 +1480,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_from_display, TestSize.Level0)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1812,8 +1497,8 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2)
         sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
         if (surfacebuffer != nullptr) {
             int32_t length = surfacebuffer->GetSize();
-            cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:"
-                << surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
+            cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:" <<
+                surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
         } else {
             cout << "AcquireVideoBuffer failed" << endl;
         }
@@ -1836,7 +1521,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1854,8 +1538,8 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2)
         sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
         if (surfacebuffer != nullptr) {
             int32_t length = surfacebuffer->GetSize();
-            cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:"
-                << surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
+            cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:" <<
+                surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl;
             screenCapture_->ReleaseVideoBuffer();
         } else {
             cout << "AcquireVideoBuffer failed" << endl;
@@ -1879,7 +1563,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0003, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1905,7 +1588,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0003, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0004, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1931,7 +1613,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0004, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0005, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1957,7 +1638,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0005, TestSize.Level2)
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_Rotation, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
 
@@ -1986,10 +1666,11 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_Rotation, TestSize.Lev
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_open_close_open, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
-    aFile = fopen("/data/screen_capture/screen_capture_mic_open_close_open.pcm", "w+");
+
+    std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_open_close_open.pcm";
+    aFile = fopen(name.c_str(), "w+");
     if (aFile == nullptr) {
         cout << "aFile audio open failed, " << strerror(errno) << endl;
     }
@@ -2023,10 +1704,11 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_open_close_open, TestSize.Lev
  */
 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_close_open_close, TestSize.Level2)
 {
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA;
-    aFile = fopen("/data/screen_capture/screen_capture_mic_close_open_close.pcm", "w+");
+
+    std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_close_open_close.pcm";
+    aFile = fopen(name.c_str(), "w+");
     if (aFile == nullptr) {
         cout << "aFile audio open failed, " << strerror(errno) << endl;
     }
@@ -2064,7 +1746,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_01, TestSize.Level2)
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = 1920;
     config_.videoInfo.videoCapInfo.videoFrameHeight = 1080;
@@ -2081,10 +1762,9 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_01, TestSize.Level2)
     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 1080, 1920));
     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
-    int32_t outputFd = open((screenCaptureRoot + "screen_capture_with_surface_01.mp4").c_str(),
-        O_RDWR | O_CREAT, 0777);
-    ASSERT_TRUE(outputFd >= 0);
-    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd));
+    OpenFileFd("screen_capture_with_surface_01.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
     EXPECT_EQ(MSERR_OK, recorder->Prepare());
     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
@@ -2113,7 +1793,6 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_02, TestSize.Level2)
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
     SetSelfTokenID(tokenID);
-    AVScreenCaptureConfig config_;
     SetConfig(config_);
     config_.videoInfo.videoCapInfo.videoFrameWidth = 640;
     config_.videoInfo.videoCapInfo.videoFrameHeight = 480;
@@ -2130,10 +1809,9 @@ HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_02, TestSize.Level2)
     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 480, 640));
     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
-    int32_t outputFd = open((screenCaptureRoot + "screen_capture_with_surface_02.mp4").c_str(),
-        O_RDWR | O_CREAT, 0777);
-    ASSERT_TRUE(outputFd >= 0);
-    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd));
+    OpenFileFd("screen_capture_with_surface_02.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
     EXPECT_EQ(MSERR_OK, recorder->Prepare());
     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
diff --git a/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test_state.cpp b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test_state.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4c21d4c53f0bfa4c6c0f4903244bb04dac2e8b3
--- /dev/null
+++ b/test/unittest/screen_capture_test/screen_capture_unittest/src/screen_capture_unit_test_state.cpp
@@ -0,0 +1,1240 @@
+/*
+ * Copyright (c) 2024 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 <fcntl.h>
+#include <iostream>
+#include <string>
+#include "media_errors.h"
+#include "screen_capture_unit_test.h"
+#include "ability_manager_client.h"
+#include "accesstoken_kit.h"
+#include "token_setproc.h"
+
+using namespace OHOS;
+using namespace OHOS::Media;
+using namespace testing::ext;
+using namespace std;
+using namespace OHOS::Rosen;
+using namespace OHOS::Media::ScreenCaptureTestParam;
+
+namespace OHOS {
+namespace Media {
+namespace {
+    constexpr int32_t FLIE_CREATE_FLAGS = 0777;
+}
+void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode)
+{
+    ASSERT_FALSE(screenCapture_->IsErrorCallBackEnabled());
+    cout << "Error received, errorCode:" << errorCode << endl;
+}
+
+void ScreenCaptureUnitTestCallback::OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type)
+{
+    cout << "OnAudioBufferAvailable S, isReady:" << isReady << endl;
+    ASSERT_FALSE(screenCapture_->IsDataCallBackEnabled());
+    if (isReady) {
+        cout << "OnAudioBufferAvailable isReady true" << endl;
+        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
+        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
+            if (audioBuffer == nullptr || audioBuffer->buffer == nullptr) {
+                cout << "AcquireAudioBuffer failed, audio buffer empty, PLEASE CHECK IF IT IS OK!!!" <<
+                    "audioBuffer:" << (audioBuffer == nullptr) << endl;
+                return;
+            }
+            cout << "AcquireAudioBuffer, audioBufferLen:" << audioBuffer->length <<
+                ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" << audioBuffer->sourcetype << endl;
+            DumpAudioBuffer(audioBuffer);
+        }
+        if (aFlag_ == 1) {
+            cout << "OnAudioBufferAvailable ReleaseAudioBuffer" << endl;
+            screenCapture_->ReleaseAudioBuffer(type);
+        }
+        cout << "OnAudioBufferAvailable isReady true E" << endl;
+    } else {
+        cout << "OnAudioBufferAvailable isReady false E" << endl;
+    }
+}
+
+void ScreenCaptureUnitTestCallback::DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)
+{
+    if ((audioBuffer == nullptr) || (audioBuffer->buffer == nullptr)) {
+        cout << "DumpAudioBuffer audioBuffer or audioBuffer->buffer is nullptr:" << (audioBuffer == nullptr) << endl;
+        return;
+    }
+    if (!screenCapture_->IsStateChangeCallBackEnabled()) {
+        if (aFile_ == nullptr) {
+            cout << "DumpAudioBuffer aFile_ is nullptr" << endl;
+            return;
+        }
+        if (fwrite(audioBuffer->buffer, 1, audioBuffer->length, aFile_) != static_cast<size_t>(audioBuffer->length)) {
+            cout << "DumpAudioBuffer error occurred in fwrite:" << strerror(errno) <<endl;
+        }
+        return;
+    }
+
+    AudioCaptureSourceType type = audioBuffer->sourcetype;
+    AVScreenCaptureBufferType bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_INVALID;
+    if (type == AudioCaptureSourceType::SOURCE_DEFAULT || type == AudioCaptureSourceType::MIC) {
+        bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC;
+        DumpBuffer(micAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
+    }
+    if (type == AudioCaptureSourceType::ALL_PLAYBACK || type == AudioCaptureSourceType::APP_PLAYBACK) {
+        bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER;
+        DumpBuffer(innerAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
+    }
+    cout << "DumpAudioBuffer invalid bufferType:" << bufferType << ", type:" << type << endl;
+}
+
+void ScreenCaptureUnitTestCallback::OnVideoBufferAvailable(bool isReady)
+{
+    cout << "OnVideoBufferAvailable S, isReady:" << isReady << endl;
+    ASSERT_FALSE(screenCapture_->IsDataCallBackEnabled());
+    if (isReady) {
+        cout << "OnVideoBufferAvailable isReady true" << endl;
+        int32_t fence = 0;
+        int64_t timestamp = 0;
+        OHOS::Rect damage;
+        sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
+        if (surfacebuffer != nullptr) {
+            int32_t length = surfacebuffer->GetSize();
+            cout << "AcquireVideoBuffer, videoBufferLen:" << surfacebuffer->GetSize() <<
+                ", timestamp:" << timestamp << ", size:"<< length << endl;
+            DumpVideoBuffer(surfacebuffer, timestamp);
+            if (vFlag_ == 1) {
+                cout << "OnVideoBufferAvailable ReleaseVideoBuffer" << endl;
+                screenCapture_->ReleaseVideoBuffer();
+            }
+        } else {
+            cout << "OnVideoBufferAvailable isReady true, AcquireVideoBuffer failed" << endl;
+        }
+    }
+}
+
+void ScreenCaptureUnitTestCallback::DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
+{
+    if ((surfacebuffer == nullptr) || (surfacebuffer->GetVirAddr() == nullptr)) {
+        cout << "DumpVideoBuffer surfacebuffer or surfacebuffer->GetVirAddr() is nullptr:" <<
+            (surfacebuffer == nullptr) << endl;
+        return;
+    }
+    if (!screenCapture_->IsStateChangeCallBackEnabled()) {
+        if (vFile_ == nullptr) {
+            cout << "DumpVideoBuffer vFile_ is nullptr" << endl;
+            return;
+        }
+        if (fwrite(surfacebuffer->GetVirAddr(), 1, surfacebuffer->GetSize(), vFile_) != surfacebuffer->GetSize()) {
+            cout << "DumpVideoBuffer error occurred in fwrite:" << strerror(errno) <<endl;
+        }
+        return;
+    }
+    DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), surfacebuffer->GetSize(),
+        timestamp, AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+}
+
+void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode, void *userData)
+{
+    ASSERT_TRUE(screenCapture_->IsErrorCallBackEnabled());
+    cout << "Error received, errorCode:" << errorCode << ", userData:" << userData << endl;
+}
+
+void ScreenCaptureUnitTestCallback::OnStateChange(AVScreenCaptureStateCode stateCode)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTestCallback::OnStateChange stateCode:%{public}d", stateCode);
+    screenCaptureState_ = stateCode;
+    cout << "OnStateChange received, stateCode:" << stateCode << endl;
+}
+
+void ScreenCaptureUnitTestCallback::OnBufferAvailable(std::shared_ptr<AVBuffer> buffer,
+    AVScreenCaptureBufferType bufferType, int64_t timestamp)
+{
+    ASSERT_TRUE(screenCapture_->IsDataCallBackEnabled());
+    MEDIA_LOGD("ScreenCaptureUnitTestCallback::OnBufferAvailable bufferType:%{public}d, timestamp:%{public}" PRId64,
+        bufferType, timestamp);
+    cout << "OnBufferAvailable received, bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
+    if (buffer == nullptr || buffer->memory_ == nullptr) {
+        return;
+    }
+    switch (bufferType) {
+        case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO: {
+            sptr<OHOS::SurfaceBuffer> surfaceBuffer = buffer->memory_->GetSurfaceBuffer();
+            if (surfaceBuffer == nullptr || surfaceBuffer->GetVirAddr() == nullptr) {
+                MEDIA_LOGW("OnBufferAvailable videoBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
+                    "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
+                cout << "OnBufferAvailable videoBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!" <<
+                    "bufferType:" << bufferType << ", timestamp:" << timestamp << (surfaceBuffer == nullptr) <<endl;
+                return;
+            }
+            ProcessVideoBuffer(surfaceBuffer, timestamp);
+            break;
+        }
+        case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER: // fall-through
+        case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC: {
+            uint8_t *auduioBuffer = buffer->memory_->GetAddr();
+            if (auduioBuffer == nullptr) {
+                MEDIA_LOGW("OnBufferAvailable audioBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
+                    "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
+                cout << "OnBufferAvailable audioBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!" <<
+                    "bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
+                return;
+            }
+            ProcessAudioBuffer(auduioBuffer, buffer->memory_->GetSize(), timestamp, bufferType);
+            break;
+        }
+        default:
+            cout << "OnBufferAvailable received invalid bufferType:" << bufferType <<
+                ", timestamp:" << timestamp << endl;
+            break;
+    }
+}
+
+void ScreenCaptureUnitTestCallback::DumpBuffer(FILE *file, uint8_t *buffer, int32_t size, int64_t timestamp,
+    AVScreenCaptureBufferType bufferType)
+{
+    cout << "DumpBuffer, bufferLen:" << size << ", bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
+    if ((file == nullptr) || (buffer == nullptr)) {
+        cout << "DumpBuffer failed, file:" << (file == nullptr) << ", buffer:" << (buffer == nullptr) <<
+            ", bufferLen:" << size << ", bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
+        return;
+    }
+    if (fwrite(buffer, 1, size, file) != static_cast<size_t>(size)) {
+        cout << "error occurred in fwrite:" << strerror(errno) << ", bufferType:" << bufferType <<
+            ", timestamp:" << timestamp << endl;
+    }
+}
+
+void ScreenCaptureUnitTestCallback::CheckDataCallbackVideo(int32_t flag)
+{
+    if (flag != 1) {
+        return;
+    }
+    if (screenCapture_->IsDataCallBackEnabled()) {
+        int32_t fence = 0;
+        int64_t timestamp = 0;
+        OHOS::Rect damage;
+        sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
+        EXPECT_EQ(nullptr, surfacebuffer);
+        EXPECT_NE(MSERR_OK, screenCapture_->ReleaseVideoBuffer());
+    }
+}
+
+void ScreenCaptureUnitTestCallback::ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
+{
+    int32_t size = surfacebuffer->GetSize();
+    DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), size, timestamp);
+    CheckDataCallbackVideo(videoFlag_);
+}
+
+void ScreenCaptureUnitTestCallback::CheckDataCallbackAudio(AudioCaptureSourceType type, int32_t flag)
+{
+    if (flag != 1) {
+        return;
+    }
+    if (screenCapture_->IsDataCallBackEnabled()) {
+        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
+        EXPECT_NE(MSERR_OK, screenCapture_->AcquireAudioBuffer(audioBuffer, type));
+        EXPECT_NE(MSERR_OK, screenCapture_->ReleaseAudioBuffer(type));
+    }
+}
+
+void ScreenCaptureUnitTestCallback::ProcessAudioBuffer(uint8_t *buffer, int32_t size, int64_t timestamp,
+    AVScreenCaptureBufferType bufferType)
+{
+    if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
+        DumpBuffer(innerAudioFile_, buffer, size, timestamp, bufferType);
+        CheckDataCallbackAudio(AudioCaptureSourceType::ALL_PLAYBACK, innerAudioFlag_);
+        return;
+    }
+    if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
+        DumpBuffer(micAudioFile_, buffer, size, timestamp, bufferType);
+        CheckDataCallbackAudio(AudioCaptureSourceType::MIC, micAudioFlag_);
+        return;
+    }
+    cout << "ProcessAudioBuffer invalid bufferType:" << bufferType << endl;
+}
+
+void ScreenCaptureUnitTestCallback::InitCaptureTrackInfo(FILE *file, int32_t flag, AVScreenCaptureBufferType bufferType)
+{
+    if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO) {
+        videoFile_ = file;
+        videoFlag_ = flag;
+    }
+    if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
+        innerAudioFile_ = file;
+        innerAudioFlag_ = flag;
+    }
+    if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
+        micAudioFile_ = file;
+        micAudioFlag_ = flag;
+    }
+}
+
+const std::string ScreenCaptureUnitTest::SCREEN_CAPTURE_ROOT_DIR = "/data/test/media/";
+
+void ScreenCaptureUnitTest::SetUpTestCase(void) {}
+
+void ScreenCaptureUnitTest::TearDownTestCase(void) {}
+
+void ScreenCaptureUnitTest::SetUp(void)
+{
+    screenCapture_ = ScreenCaptureMockFactory::CreateScreenCapture();
+    ASSERT_NE(nullptr, screenCapture_);
+}
+
+void ScreenCaptureUnitTest::TearDown(void)
+{
+    if (screenCaptureCb_ != nullptr) {
+        screenCaptureCb_.reset();
+        screenCaptureCb_ = nullptr;
+    }
+    if (screenCapture_ != nullptr) {
+        screenCapture_->Release();
+        screenCapture_ = nullptr;
+    }
+}
+
+int32_t ScreenCaptureUnitTest::SetConfig(AVScreenCaptureConfig &config)
+{
+    AudioCaptureInfo miccapinfo = {
+        .audioSampleRate = 16000,
+        .audioChannels = 2,
+        .audioSource = SOURCE_DEFAULT
+    };
+
+    VideoCaptureInfo videocapinfo = {
+        .videoFrameWidth = 720,
+        .videoFrameHeight = 1280,
+        .videoSource = VIDEO_SOURCE_SURFACE_RGBA
+    };
+
+    VideoEncInfo videoEncInfo = {
+        .videoCodec = VideoCodecFormat::H264,
+        .videoBitrate = 2000000,
+        .videoFrameRate = 30
+    };
+
+    AudioInfo audioinfo = {
+        .micCapInfo = miccapinfo,
+    };
+
+    VideoInfo videoinfo = {
+        .videoCapInfo = videocapinfo,
+        .videoEncInfo = videoEncInfo
+    };
+
+    config = {
+        .captureMode = CAPTURE_HOME_SCREEN,
+        .dataType = ORIGINAL_STREAM,
+        .audioInfo = audioinfo,
+        .videoInfo = videoinfo
+    };
+    return MSERR_OK;
+}
+
+int32_t ScreenCaptureUnitTest::SetConfigFile(AVScreenCaptureConfig &config, RecorderInfo &recorderInfo)
+{
+    AudioEncInfo audioEncInfo = {
+        .audioBitrate = 48000,
+        .audioCodecformat = AudioCodecFormat::AAC_LC
+    };
+
+    VideoCaptureInfo videoCapInfo = {
+        .videoFrameWidth = 720,
+        .videoFrameHeight = 1080,
+        .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
+    };
+
+    VideoEncInfo videoEncInfo = {
+        .videoCodec = VideoCodecFormat::H264,
+        .videoBitrate = 2000000,
+        .videoFrameRate = 30
+    };
+
+    AudioCaptureInfo innerCapInfo = {
+        .audioSampleRate = 0,
+        .audioChannels = 0,
+        .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
+    };
+
+    AudioCaptureInfo micCapInfo = {
+        .audioSampleRate = 0,
+        .audioChannels = 0,
+        .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
+    };
+
+    AudioInfo audioInfo = {
+        .micCapInfo = micCapInfo,
+        .innerCapInfo = innerCapInfo,
+        .audioEncInfo = audioEncInfo
+    };
+
+    VideoInfo videoInfo = {
+        .videoCapInfo = videoCapInfo,
+        .videoEncInfo = videoEncInfo
+    };
+
+    config = {
+        .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
+        .dataType = DataType::CAPTURE_FILE,
+        .audioInfo = audioInfo,
+        .videoInfo = videoInfo,
+        .recorderInfo = recorderInfo
+    };
+    return MSERR_OK;
+}
+
+void ScreenCaptureUnitTest::OpenFile(std::string name, bool isInnerAudioEnabled, bool isMicAudioEnabled,
+    bool isVideoEnabled)
+{
+    if (isInnerAudioEnabled) {
+        std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s_inner.pcm";
+        if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
+            name.c_str()) >= 0) {
+            innerAudioFile_ = fopen(fileName, "w+");
+            if (innerAudioFile_ == nullptr) {
+                cout << "micAudioFile_ open failed, " << strerror(errno) << endl;
+            }
+        } else {
+            cout << "snprintf micAudioFile_ failed, " << strerror(errno) << endl;
+            return;
+        }
+    }
+    if (isMicAudioEnabled) {
+        std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s_mic.pcm";
+        if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
+            name.c_str()) >= 0) {
+            micAudioFile_ = fopen(fileName, "w+");
+            if (micAudioFile_ == nullptr) {
+                cout << "micAudioFile_ open failed, " << strerror(errno) << endl;
+            }
+        } else {
+            cout << "snprintf micAudioFile_ failed, " << strerror(errno) << endl;
+            return;
+        }
+    }
+    if (isVideoEnabled) {
+        std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.yuv";
+        if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
+            name.c_str()) >= 0) {
+            videoFile_ = fopen(fileName, "w+");
+            if (videoFile_ == nullptr) {
+                cout << "videoFile_ open failed, " << strerror(errno) << endl;
+            }
+        } else {
+            cout << "snprintf videoFile_ failed, " << strerror(errno) << endl;
+            return;
+        }
+    }
+}
+
+int32_t ScreenCaptureUnitTest::SetRecorderInfo(std::string name, RecorderInfo &recorderInfo)
+{
+    OpenFileFd(name);
+    recorderInfo.url = "fd://" + to_string(outputFd_);
+    recorderInfo.fileFormat = "mp4";
+    return MSERR_OK;
+}
+
+void ScreenCaptureUnitTest::OpenFileFd(std::string name)
+{
+    outputFd_ = open((SCREEN_CAPTURE_ROOT_DIR + name).c_str(), O_RDWR | O_CREAT, FLIE_CREATE_FLAGS);
+}
+
+void ScreenCaptureUnitTest::OpenFile(std::string name)
+{
+    std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.pcm";
+    if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
+        name.c_str()) >= 0) {
+        aFile = fopen(fileName, "w+");
+        if (aFile == nullptr) {
+            cout << "aFile audio open failed, " << strerror(errno) << endl;
+        }
+    } else {
+        cout << "snprintf audio file failed, " << strerror(errno) << endl;
+        return;
+    }
+    nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.yuv";
+    if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
+        name.c_str()) >= 0) {
+        vFile = fopen(fileName, "w+");
+        if (vFile == nullptr) {
+            cout << "vFile video open failed, " << strerror(errno) << endl;
+        }
+    } else {
+        cout << "snprintf video file failed, " << strerror(errno) << endl;
+        return;
+    }
+}
+
+void ScreenCaptureUnitTest::CloseFile(void)
+{
+    if (aFile != nullptr) {
+        fclose(aFile);
+        aFile = nullptr;
+    }
+    if (vFile != nullptr) {
+        fclose(vFile);
+        vFile = nullptr;
+    }
+    if (videoFile_ != nullptr) {
+        fclose(videoFile_);
+        videoFile_ = nullptr;
+    }
+    if (innerAudioFile_ != nullptr) {
+        fclose(innerAudioFile_);
+        innerAudioFile_ = nullptr;
+    }
+    if (micAudioFile_ != nullptr) {
+        fclose(micAudioFile_);
+        micAudioFile_ = nullptr;
+    }
+    if (outputFd_ != -1) {
+        (void)::close(outputFd_);
+        outputFd_ = -1;
+    }
+}
+
+void ScreenCaptureUnitTest::AudioLoop(void)
+{
+    int index_ = 200;
+    int index_audio_frame = 0;
+    while (index_) {
+        if (screenCapture_ == nullptr) {
+            break;
+        }
+        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
+        AudioCaptureSourceType type = MIC;
+        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
+            if (audioBuffer == nullptr) {
+                cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
+                continue;
+            }
+            cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:" <<
+                audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" <<
+                audioBuffer->sourcetype << endl;
+            screenCapture_->ReleaseAudioBuffer(type);
+        } else {
+            cout << "AcquireAudioBuffer failed" << endl;
+        }
+        index_--;
+    }
+}
+
+void ScreenCaptureUnitTest::AudioLoopWithoutRelease(void)
+{
+    int index_ = 200;
+    int index_audio_frame = 0;
+    while (index_) {
+        if (screenCapture_ == nullptr) {
+            break;
+        }
+        std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
+        AudioCaptureSourceType type = MIC;
+        if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
+            if (audioBuffer == nullptr) {
+                cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
+                continue;
+            }
+            cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:" <<
+                audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" <<
+                audioBuffer->sourcetype << endl;
+        } else {
+            cout << "AcquireAudioBuffer failed" << endl;
+        }
+        index_--;
+    }
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_01
+ * @tc.desc: open microphone, capture screen, inner audio, mic audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_01, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_01";
+    // track enalbed: inner: true, mic: true, video: true
+    OpenFile(name, true, true, true);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    bool isMicrophone = true; // Enable Mic
+    screenCapture_->SetMicrophoneEnabled(isMicrophone);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_02
+ * @tc.desc: diable microphone, capture screen, inner audio, mic audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_02, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_02";
+    // track enalbed: inner: true, mic: true, video: true
+    OpenFile(name, true, true, true);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(false); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_03
+ * @tc.desc: Enable microphone, capture screen, mic audio
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_03, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_03";
+    // track enalbed: inner: false, mic: true, video: true
+    OpenFile(name, false, true, true);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_04
+ * @tc.desc: Enable microphone, capture screen, inner audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_04, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_04";
+    // track enalbed: inner: true, mic: false, video: true
+    OpenFile(name, true, false, true);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_05
+ * @tc.desc: Enable microphone, capture inner audio, mic audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_05, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
+    config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_05";
+    // track enalbed: inner: true, mic: true, video: false
+    OpenFile(name, true, true, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_06
+ * @tc.desc: Enable microphone, capture inner audio only
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_06, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
+    config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_06";
+    // track enalbed: inner: true, mic: false, video: false
+    OpenFile(name, true, false, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 after");
+}
+
+/**
+ * @tc.name: screen_capture_specified_window_cb_07
+ * @tc.desc: Enable microphone, capture screen only
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_07, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
+    std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
+    std::string deviceId = "";
+    std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
+    auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 result : %{public}d", result);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 size : %{public}s",
+        std::to_string(missionInfos.size()).c_str());
+    for (OHOS::AAFwk::MissionInfo info : missionInfos) {
+        MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 missionId : %{public}d", info.id);
+        config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
+    }
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    std::string name = "screen_capture_specified_window_cb_07";
+    // track enalbed: inner: false, mic: false, video: true
+    OpenFile(name, false, false, true);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 after");
+}
+
+/**
+ * @tc.name: screen_capture_save_file_cb_01
+ * @tc.desc: do screencapture capture file mode, capture inner audio and mic audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_01, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 before");
+    RecorderInfo recorderInfo;
+    SetRecorderInfo("screen_capture_save_file_cb_01.mp4", recorderInfo);
+    SetConfigFile(config_, recorderInfo);
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 after");
+}
+
+/**
+ * @tc.name: screen_capture_save_file_cb_02
+ * @tc.desc: do screencapture capture file mode, capture inner audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_02, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 before");
+    RecorderInfo recorderInfo;
+    SetRecorderInfo("screen_capture_save_file_cb_02.mp4", recorderInfo);
+    SetConfigFile(config_, recorderInfo);
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+    // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true));
+
+    screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 after");
+}
+
+/**
+ * @tc.name: screen_capture_with_surface_cb_01
+ * @tc.desc: do screencapture capture surface mode, capture screen, inner audio and mic audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_01, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    bool isMicrophone = true;
+    screenCapture_->SetMicrophoneEnabled(isMicrophone);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 CreateRecorder");
+    std::shared_ptr<Recorder> recorder = nullptr;
+    recorder = RecorderFactory::CreateRecorder();
+    int32_t videoSourceId = 0;
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 1080, 1920));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
+    OpenFileFd("screen_capture_with_surface_cb_01.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
+    EXPECT_EQ(MSERR_OK, recorder->Prepare());
+    sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+
+    std::string name = "screen_capture_with_surface_cb_01";
+    // track enalbed: inner: true, mic: true, video: true(surface mode)
+    OpenFile(name, true, true, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
+    EXPECT_EQ(MSERR_OK, recorder->Start());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 recorder Start");
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, recorder->Stop(true));
+    EXPECT_EQ(MSERR_OK, recorder->Reset());
+    EXPECT_EQ(MSERR_OK, recorder->Release());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 after");
+}
+
+/**
+ * @tc.name: screen_capture_with_surface_cb_02
+ * @tc.desc: do screencapture capture surface mode, capture screen and inner audio
+ * @tc.type: FUNC
+ * @tc.require: play something audio resource to get inner audio
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_02, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
+    config_.audioInfo.innerCapInfo.audioChannels = 2;
+    config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
+    screenCapture_->SetMicrophoneEnabled(true);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 CreateRecorder");
+    std::shared_ptr<Recorder> recorder = nullptr;
+    recorder = RecorderFactory::CreateRecorder();
+    int32_t videoSourceId = 0;
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 1080, 1920));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
+    OpenFileFd("screen_capture_with_surface_cb_02.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
+    EXPECT_EQ(MSERR_OK, recorder->Prepare());
+    sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+
+    std::string name = "screen_capture_with_surface_cb_02";
+    // track enalbed: inner: true, mic: false, video: true(surface mode)
+    OpenFile(name, true, false, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
+    EXPECT_EQ(MSERR_OK, recorder->Start());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 recorder Start");
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, recorder->Stop(true));
+    EXPECT_EQ(MSERR_OK, recorder->Reset());
+    EXPECT_EQ(MSERR_OK, recorder->Release());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 after");
+}
+
+/**
+ * @tc.name: screen_capture_with_surface_cb_03
+ * @tc.desc: do screencapture capture surface mode, capture screen and mic audio
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_03, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    screenCapture_->SetMicrophoneEnabled(true);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 CreateRecorder");
+    std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
+    int32_t videoSourceId = 0;
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 1080, 1920));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
+    OpenFileFd("screen_capture_with_surface_cb_03.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
+    EXPECT_EQ(MSERR_OK, recorder->Prepare());
+    sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+
+    std::string name = "screen_capture_with_surface_cb_03";
+    // track enalbed: inner: false, mic: true, video: true(surface mode)
+    OpenFile(name, false, true, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
+    EXPECT_EQ(MSERR_OK, recorder->Start());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 recorder Start");
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, recorder->Stop(true));
+    EXPECT_EQ(MSERR_OK, recorder->Reset());
+    EXPECT_EQ(MSERR_OK, recorder->Release());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 after");
+}
+
+/**
+ * @tc.name: screen_capture_with_surface_cb_04
+ * @tc.desc: do screencapture capture surface mode, capture screen only
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_04, TestSize.Level2)
+{
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 before");
+    Security::AccessToken::AccessTokenID tokenID =
+        Security::AccessToken::AccessTokenKit::GetNativeTokenId("distributedsched");
+    SetSelfTokenID(tokenID);
+    SetConfig(config_);
+    config_.audioInfo.micCapInfo.audioSampleRate = 0;
+    config_.audioInfo.micCapInfo.audioChannels = 0;
+    config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
+    screenCapture_->SetMicrophoneEnabled(true);
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 CreateRecorder");
+    std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
+    int32_t videoSourceId = 0;
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 1080, 1920));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
+    EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
+    OpenFileFd("screen_capture_with_surface_cb_04.mp4");
+    ASSERT_TRUE(outputFd_ >= 0);
+    EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
+    EXPECT_EQ(MSERR_OK, recorder->Prepare());
+    sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
+
+    screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
+    ASSERT_NE(nullptr, screenCaptureCb_);
+
+    std::string name = "screen_capture_with_surface_cb_04";
+    // track enalbed: inner: false, mic: false, video: true(surface mode)
+    OpenFile(name, false, false, false);
+    // check track aquire & release: inner: 1, mic: 1, video: 1
+    screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
+    screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
+    screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
+    // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
+    EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
+
+    EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
+    EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
+    EXPECT_EQ(MSERR_OK, recorder->Start());
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 recorder Start");
+    sleep(RECORDER_TIME);
+    EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
+    EXPECT_EQ(MSERR_OK, recorder->Stop(true));
+    EXPECT_EQ(MSERR_OK, recorder->Reset());
+    EXPECT_EQ(MSERR_OK, recorder->Release());
+    EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
+    EXPECT_EQ(MSERR_OK, screenCapture_->Release());
+    CloseFile();
+    MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 after");
+}
+} // namespace Media
+} // namespace OHOS
\ No newline at end of file