diff --git a/common/BUILD.gn b/common/BUILD.gn
index 7dd03dcd631fe907e5d57d8a7e6079f71e38c6f3..17038a32ec9bb84f8ea382ca8bf097b4420fcf5d 100644
--- a/common/BUILD.gn
+++ b/common/BUILD.gn
@@ -33,6 +33,7 @@ ohos_shared_library("distributed_screen_utils") {
     external_deps = [
         "dsoftbus_standard:softbus_client",
         "hiviewdfx_hilog_native:libhilog",
+        "bytrace_standard:bytrace_core",
     ]
 
     defines = [
diff --git a/common/include/dscreen_hitrace.h b/common/include/dscreen_hitrace.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7b764f4d5c49c89b6584b14c776e13e56cfb321
--- /dev/null
+++ b/common/include/dscreen_hitrace.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DSCREEN_HITRACE_H
+#define OHOS_DSCREEN_HITRACE_H
+
+#include <string>
+
+#include "bytrace.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+const std::string DSCREEN_HANDLER_TASK_START = "DSCREEN_HANDLER_START";
+const std::string DSCREEN_HANDLER_TASK_ENABLE_START = "DSCREEN_HANDLER_TASK_ENABLE_START";
+const std::string DSCREEN_HANDLER_TASK_DISABLE_START = "DSCREEN_HANDLER_TASK_DISABLE_START";
+const std::string DSCREEN_HANDLER_TASK_CONNECT_START = "DSCREEN_HANDLER_TASK_CONNECT_START";
+const std::string DSCREEN_HANDLER_TASK_DISCONNECT_START = "DSCREEN_HANDLER_TASK_DISCONNECT_START";
+
+constexpr uint64_t DSCREEN_HANDLER_TASK_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_TASK_ENABLE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_TASK_DISABLE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_TASK_CONNECT_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_TASK_DISCONNECT_LABEL = BYTRACE_TAG_OHOS;
+
+const std::string DSCREEN_HANDLER_ENABLE_START = "DSCREEN_HANDLER_ENABLE_START";
+const std::string DSCREEN_HANDLER_DISENABLE_START = "DSCREEN_HANDLER_DISENABLE_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK0_START = "DSCREEN_HANDLER_ENABLE_CALLBACK0_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK1_START = "DSCREEN_HANDLER_ENABLE_CALLBACK1_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK2_START = "DSCREEN_HANDLER_ENABLE_CALLBACK2_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK3_START = "DSCREEN_HANDLER_ENABLE_CALLBACK3_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK4_START = "DSCREEN_HANDLER_ENABLE_CALLBACK4_START";
+const std::string DSCREEN_HANDLER_ENABLE_CALLBACK5_START = "DSCREEN_HANDLER_ENABLE_CALLBACK5_START";
+const std::string DSCREEN_NEGOTIATE_CODEC_START = "DSCREEN_NEGOTIATE_CODEC_START";
+const std::string DSCREEN_ENABLE_DISTRIBUTED_SCREEN_START = "DSCREEN_ENABLE_DISTRIBUTED_SCREEN_START";
+const std::string DSCREEN_DISABLE_DISTRIBUTED_SCREEN_START = "DSCREEN_DISABLE_DISTRIBUTED_SCREEN_START";
+const std::string DSCREEN_HANDLE_NOTIFY_SETUPRESULT_START = "DSCREEN_HANDLE_NOTIFY_SETUPRESULT_START";
+const std::string DSCREEN_GETDISCREEN_SINK_START = "DSCREEN_GETDISCREEN_SINK_START";
+const std::string DSCREEN_CREATE_VIRTUAL_SCREEN_START = "DSCREEN_CREATE_VIRTUAL_SCREEN_START";
+const std::string DSCREEN_INIT_SOURCE_START = "DSCREEN_INIT_SOURCE_START";
+const std::string DSCREEN_RELEASE_SOURCE_START = "DSCREEN_RELEASE_SOURCE_START";
+const std::string DSCREEN_REGISTER_DISTRIBUTED_START = "DSCREEN_REGISTER_DISTRIBUTED_START";
+const std::string DSCREEN_UNREGISTER_DISTRIBUTED_START = "DSCREEN_UNREGISTER_DISTRIBUTED_START";
+const std::string DSCREEN_CREAT_SESSION_START = "DSCREEN_CREAT_SESSION_START";
+const std::string DSCREEN_RELEASE_SESSION_START = "DSCREEN_RELEASE_SESSION_START";
+const std::string DSCREEN_OPEN_SESSION_START = "DSCREEN_OPEN_SESSION_START";
+const std::string DSCREEN_CLOSE_SESSION_START = "DSCREEN_CLOSE_SESSION_START";
+const std::string DSCREEN_SEND_DATA_START = "DSCREEN_SEND_DATA_START";
+const std::string DSCREEN_ON_SESSION_OPEN_START = "DSCREEN_ON_SESSION_OPEN_START";
+const std::string DSCREEN_ON_SESSION_CLOSE_START = "DSCREEN_ON_SESSION_CLOSE_START";
+const std::string DSCREEN_ON_STREAM_RECEIVED_START = "DSCREEN_ON_STREAM_RECEIVED_START";
+const std::string DSCREEN_IMAGE_DECODER_CALLBACK_START = "DSCREEN_IMAGE_DECODER_CALLBACK_START";
+const std::string DSCREEN_ON_OUTPUT_BUFFER_START = "DSCREEN_ON_OUTPUT_BUFFER_START";
+const std::string DSCREEN_ONINPUT_BUFFER_START = "DSCREEN_ONINPUT_BUFFER_START";
+const std::string DSCREEN_ON_OUTPUT_FORMAT_START = "DSCREEN_ON_OUTPUT_FORMAT_START";
+
+constexpr uint64_t DSCREEN_IMAGE_DECODER_CALLBACK_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ON_OUTPUT_BUFFER_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ONINPUT_BUFFER_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ON_OUTPUT_FORMAT_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_CREAT_SESSION_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_RELEASE_SESSION_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_OPEN_SESSION_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_CLOSE_SESSION_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_SEND_DATA_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ON_SESSION_OPEN_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ON_SESSION_CLOSE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ON_STREAM_RECEIVED_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_INIT_SOURCE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_RELEASE_SOURCE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_REGISTER_DISTRIBUTED_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_UNREGISTER_DISTRIBUTED_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_CREATE_VIRTUAL_SCREEN_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_GETDISCREEN_SINK_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLE_NOTIFY_SETUPRESULT_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_DISENABLE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_NEGOTIATE_CODEC_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_ENABLE_DISTRIBUTED_SCREEN_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_DISABLE_DISTRIBUTED_SCREEN_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK0_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK1_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK2_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK3_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK4_LABEL = BYTRACE_TAG_OHOS;
+constexpr uint64_t DSCREEN_HANDLER_ENABLE_CALLBACK5_LABEL = BYTRACE_TAG_OHOS;
+
+enum TASKID {
+    DSCREEN_CALLBACK0,
+    DSCREEN_CALLBACK1,
+    DSCREEN_CALLBACK2,
+    DSCREEN_CALLBACK3,
+    DSCREEN_CALLBACK4,
+    DSCREEN_CALLBACK5,
+    DSCREEN_CALLBACK5,
+};
+}
+}
+#endif
\ No newline at end of file
diff --git a/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp b/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp
index d6e73fdbbbe5acd7a50999de017b9dede06e7f7c..77bfb8a0bd4947741aca261bf6268c8ea1ded84c 100644
--- a/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp
+++ b/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp
@@ -20,6 +20,7 @@
 
 #include "dscreen_constants.h"
 #include "dscreen_errcode.h"
+#include "dscreen_hitrace.h"
 #include "dscreen_log.h"
 #include "dscreen_util.h"
 #include "screen_manager_adapter.h"
@@ -158,32 +159,44 @@ void DScreen::TaskThreadLoop()
 
 void DScreen::HandleTask(const std::shared_ptr<Task> &task)
 {
+    StartTrace(DSCREEN_HANDLER_TASK_LABEL, DSCREEN_HANDLER_TASK_START);
     int32_t taskType = task->GetTaskType();
     DHLOGI("HandleTask, devId: %s, dhId: %s, task type: %d", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str(), taskType);
     switch (taskType) {
         case TaskType::TASK_ENABLE:
+            StartTrace(DSCREEN_HANDLER_TASK_ENABLE_LABEL, DSCREEN_HANDLER_TASK_ENABLE_START);
             HandleEnable(task->GetTaskParam(), task->GetTaskId());
+            FinishTrace(DSCREEN_HANDLER_TASK_ENABLE_LABEL);
             break;
         case TaskType::TASK_DISABLE:
+            StartTrace(DSCREEN_HANDLER_TASK_DISABLE_LABEL, DSCREEN_HANDLER_TASK_DISABLE_START);
             HandleDisable(task->GetTaskId());
+            FinishTrace(DSCREEN_HANDLER_TASK_DISABLE_LABEL);
             break;
         case TaskType::TASK_CONNECT:
+            StartTrace(DSCREEN_HANDLER_TASK_CONNECT_LABEL, DSCREEN_HANDLER_TASK_CONNECT_START);
             HandleConnect();
+            FinishTrace(DSCREEN_HANDLER_TASK_CONNECT_LABEL);
             break;
         case TaskType::TASK_DISCONNECT:
+            StartTrace(DSCREEN_HANDLER_TASK_DISCONNECT_LABEL, DSCREEN_HANDLER_TASK_DISCONNECT_START);
             HandleDisconnect();
+            FinishTrace(DSCREEN_HANDLER_TASK_DISCONNECT_LABEL);
             break;
         default:
             DHLOGD("task type unkown.");
     }
+    FinishTrace(DSCREEN_HANDLER_TASK_LABEL);
 }
 
 void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
 {
+    StartTrace(DSCREEN_HANDLER_ENABLE_LABEL, DSCREEN_HANDLER_ENABLE_START);
     DHLOGI("HandleEnable, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
     if (curState_ == ENABLED || curState_ == ENABLING ||
         curState_ == CONNECTING || curState_ == CONNECTED) {
+        StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK0_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK0_START, DSCREEN_CALLBACK0);
         dscreenCallback_->OnRegResult(shared_from_this(), taskId, DH_SUCCESS, "");
         return;
     }
@@ -196,6 +209,7 @@ void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
     json attrJson = json::parse(param, nullptr, false);
     if (attrJson.is_discarded()) {
         DHLOGE("enable param json is invalid.");
+        StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK1_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK1_START, DSCREEN_CALLBACK1);
         dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED,
             "enable param json is invalid.");
         return;
@@ -204,6 +218,7 @@ void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
     if (!attrJson.contains(KEY_SCREEN_WIDTH) ||
         !attrJson.contains(KEY_SCREEN_HEIGHT) ||
         !attrJson.contains(KEY_CODECTYPE)) {
+        StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK2_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK2_START, DSCREEN_CALLBACK2);
         DHLOGE("enable param is invalid.");
         dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED,
             "enable param is invalid.");
@@ -216,6 +231,7 @@ void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
     // negotiate codecType
     int32_t ret = NegotiateCodecType(attrJson[KEY_CODECTYPE]);
     if (ret != DH_SUCCESS) {
+        StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK3_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK3_START, DSCREEN_CALLBACK3);
         DHLOGE("negotiate codec type failed.");
         dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED,
             "negotiate codec type failed.");
@@ -224,6 +240,7 @@ void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
 
     uint64_t screenId = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId_, dhId_, videoParam_);
     if (screenId == SCREEN_ID_INVALID) {
+        StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK4_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK4_START, DSCREEN_CALLBACK4);
         DHLOGE("create virtual screen failed.");
         dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED,
             "create virtual screen failed.");
@@ -231,11 +248,14 @@ void DScreen::HandleEnable(const std::string &param, const std::string &taskId)
     }
     screenId_ = screenId;
     SetState(ENABLED);
+    StartAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK5_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK5_START, DSCREEN_CALLBACK5);
     dscreenCallback_->OnRegResult(shared_from_this(), taskId, DH_SUCCESS, "");
+    FinishTrace(DSCREEN_HANDLER_ENABLE_LABEL);
 }
 
 int32_t DScreen::NegotiateCodecType(const std::string &remoteCodecInfoStr)
 {
+    StartTrace(DSCREEN_NEGOTIATE_CODEC_LABEL, DSCREEN_NEGOTIATE_CODEC_START);
     json remoteCodecArray = json::parse(remoteCodecInfoStr, nullptr, false);
     if (remoteCodecArray.is_discarded() || !remoteCodecArray.is_array()) {
         DHLOGE("remoteCodecInfoStrjson is invalid.");
@@ -271,12 +291,13 @@ int32_t DScreen::NegotiateCodecType(const std::string &remoteCodecInfoStr)
         DHLOGI("codec type not support.");
         return ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL;
     }
-
+    FinishTrace(DSCREEN_NEGOTIATE_CODEC_LABEL);
     return DH_SUCCESS;
 }
 
 void DScreen::HandleDisable(const std::string &taskId)
 {
+    StartTrace(DSCREEN_HANDLER_DISENABLE_LABEL, DSCREEN_HANDLER_ENABLE_START);
     DHLOGI("HandleDisable, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
     SetState(DISABLING);
     Stop();
@@ -289,6 +310,7 @@ void DScreen::HandleDisable(const std::string &taskId)
     }
     SetState(DISABLED);
     dscreenCallback_->OnUnregResult(shared_from_this(), taskId, DH_SUCCESS, "");
+    FinishTrace(DSCREEN_HANDLER_DISENABLE_LABEL);
 }
 
 void DScreen::HandleConnect()
diff --git a/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp b/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp
index 49812b88b44a4983ab4f00b7b73a865fed7359bf..238476042418d693067528454fb10bf3d2ebb5ef 100644
--- a/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp
+++ b/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp
@@ -21,6 +21,7 @@
 
 #include "dscreen_constants.h"
 #include "dscreen_errcode.h"
+#include "dscreen_hitrace.h"
 #include "dscreen_log.h"
 #include "dscreen_util.h"
 #include "idscreen_sink.h"
@@ -160,6 +161,18 @@ void DScreenCallback::OnRegResult(const std::shared_ptr<DScreen> &dScreen,
     DHLOGI("DScreenCallback::OnRegResult, devId: %s, dhId: %s, reqId: %s",
         GetAnonyString(dScreen->GetDevId()).c_str(), GetAnonyString(dScreen->GetDHId()).c_str(), reqId.c_str());
     DScreenManager::GetInstance().OnRegResult(dScreen, reqId, status, data);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK0_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK0_START,
+        DSCREEN_CALLBACK0);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK1_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK1_START,
+        DSCREEN_CALLBACK1);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK2_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK2_START,
+        DSCREEN_CALLBACK2);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK3_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK3_START,
+        DSCREEN_CALLBACK3);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK4_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK4_START,
+        DSCREEN_CALLBACK4);
+    FinishAsyncTrace(DSCREEN_HANDLER_ENABLE_CALLBACK5_LABEL, DSCREEN_HANDLER_ENABLE_CALLBACK5_START,
+        DSCREEN_CALLBACK5);
 }
 
 void DScreenCallback::OnUnregResult(const std::shared_ptr<DScreen> &dScreen,
@@ -197,6 +210,7 @@ void DScreenManager::OnUnregResult(const std::shared_ptr<DScreen> &dScreen,
 int32_t DScreenManager::EnableDistributedScreen(const std::string &devId, const std::string &dhId,
     const std::string &attrs, const std::string &reqId)
 {
+    StartTrace(DSCREEN_ENABLE_DISTRIBUTED_SCREEN_LABEL, DSCREEN_ENABLE_DISTRIBUTED_SCREEN_START);
     DHLOGI("EnableDistributedScreen, devId: %s, dhId:%s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
     if (!dScreenCallback_) {
@@ -226,12 +240,14 @@ int32_t DScreenManager::EnableDistributedScreen(const std::string &devId, const
         DHLOGE("EnableDistributedScreen, add task failed. devId: %s, dhId:%s",
             GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
     }
+    FinishTrace(DSCREEN_ENABLE_DISTRIBUTED_SCREEN_LABEL);
     return ret;
 }
 
 int32_t DScreenManager::DisableDistributedScreen(const std::string &devId, const std::string &dhId,
     const std::string &reqId)
 {
+    StartTrace(DSCREEN_DISABLE_DISTRIBUTED_SCREEN_LABEL, DSCREEN_ENABLE_DISTRIBUTED_SCREEN_START);
     DHLOGI("DisableDistributedScreen, devId: %s, dhId:%s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
 
@@ -266,6 +282,7 @@ int32_t DScreenManager::DisableDistributedScreen(const std::string &devId, const
             ret = ERR_DH_SCREEN_SA_DISABLE_FAILED;
             break;
     }
+    FinishTrace(DSCREEN_DISABLE_DISTRIBUTED_SCREEN_LABEL);
     return ret;
 }
 
@@ -328,6 +345,7 @@ int32_t DScreenManager::NotifyRemoteScreenService(const std::string &devId, int3
 sptr<IDScreenSink> DScreenManager::GetDScreenSinkSA(const std::string &devId)
 {
     DHLOGI("GetDScreenSinkSA, devId: %s", GetAnonyString(devId).c_str());
+    StartTrace(DSCREEN_GETDISCREEN_SINK_LABEL, DSCREEN_GETDISCREEN_SINK_START);
     sptr<ISystemAbilityManager> samgr =
         SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (!samgr) {
@@ -345,6 +363,7 @@ sptr<IDScreenSink> DScreenManager::GetDScreenSinkSA(const std::string &devId)
         DHLOGE("Failed to get remote dscreen sink sa");
         return nullptr;
     }
+    FinishTrace(DSCREEN_GETDISCREEN_SINK_LABEL);
     return remoteSinkSA;
 }
 
@@ -378,6 +397,7 @@ void DScreenManager::NotifyRemoteSinkSetUp(const std::shared_ptr<DScreen> &dScre
 void DScreenManager::HandleNotifySetUpResult(const std::string &remoteDevId, const std::string &eventContent)
 {
     DHLOGI("HandleNotifySetUpResult, remoteDevId:%s", GetAnonyString(remoteDevId).c_str());
+    StartTrace(DSCREEN_HANDLE_NOTIFY_SETUPRESULT_LABEL, DSCREEN_HANDLE_NOTIFY_SETUPRESULT_START);
     json eventContentJson = json::parse(eventContent, nullptr, false);
     if (eventContentJson.is_discarded()) {
         DHLOGE("HandleNotifySetUpResult, eventContent is invalid");
@@ -409,6 +429,7 @@ void DScreenManager::HandleNotifySetUpResult(const std::string &remoteDevId, con
     }
 
     dScreens_[dScreenIdx]->AddTask(std::make_shared<Task>(TaskType::TASK_CONNECT, ""));
+    FinishTrace(DSCREEN_HANDLE_NOTIFY_SETUPRESULT_LABEL);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp b/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp
index 4f0850bfb97257fef19a0b4a726e083042500a05..50d39ad5d25cad9200c97e2f8a2981cedfe272b0 100644
--- a/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp
+++ b/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp
@@ -38,6 +38,7 @@ uint64_t ScreenMgrAdapter::CreateVirtualScreen(const std::string &devId, const s
 {
     DHLOGI("CreateVirtualScreen, width: %u, height: %u", videoParam->GetScreenWidth(),
         videoParam->GetScreenHeight());
+    StartTrace(DSCREEN_CREATE_VIRTUAL_SCREEN_LABEL, DSCREEN_CREATE_VIRTUAL_SCREEN_START);
     std::string screenName = DSCREEN_PREFIX + SEPERATOR + devId + SEPERATOR + dhId;
     Rosen::VirtualScreenOption option = {
         screenName,
@@ -50,6 +51,7 @@ uint64_t ScreenMgrAdapter::CreateVirtualScreen(const std::string &devId, const s
     };
 
     uint64_t screenId = Rosen::ScreenManager::GetInstance().CreateVirtualScreen(option);
+    FinishTrace(DSCREEN_CREATE_VIRTUAL_SCREEN_LABEL);
     return screenId;
 }
 
diff --git a/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp b/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp
index e1cb0ef3530824bcaaac58a418cfc7ad6d814d72..c3dec78246547762399a4687e28714445befa266 100644
--- a/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp
+++ b/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp
@@ -75,6 +75,7 @@ bool DScreenSourceService::Init()
 int32_t DScreenSourceService::InitSource(const std::string &params, const sptr<IDScreenSourceCallback> &callback)
 {
     DHLOGI("InitSource");
+    StartTrace(DSCREEN_INIT_SOURCE_LABEL, DSCREEN_INIT_SOURCE_START);
     int32_t ret = DScreenManager::GetInstance().Init();
     if (ret != DH_SUCCESS) {
         DHLOGE("Init DScreenManager failed. err: %d", ret);
@@ -82,17 +83,20 @@ int32_t DScreenSourceService::InitSource(const std::string &params, const sptr<I
     }
 
     DScreenManager::GetInstance().RegisterDScreenCallback(callback);
+    FinishTrace(DSCREEN_INIT_SOURCE_LABEL);
     return DH_SUCCESS;
 }
 
 int32_t DScreenSourceService::ReleaseSource()
 {
     DHLOGI("ReleaseSource");
+    StartTrace(DSCREEN_RELEASE_SOURCE_LABEL, DSCREEN_INIT_SOURCE_START);
     int32_t ret = DScreenManager::GetInstance().UnInit();
     if (ret != DH_SUCCESS) {
         DHLOGE("UnInit DScreenManager failed. err: %d", ret);
         return ret;
     }
+    FinishTrace(DSCREEN_RELEASE_SOURCE_LABEL);
     return DH_SUCCESS;
 }
 
@@ -100,6 +104,7 @@ int32_t DScreenSourceService::RegisterDistributedHardware(const std::string &dev
     const EnableParam &param, const std::string &reqId)
 {
     DHLOGI("RegisterDistributedHardware");
+    StartTrace(DSCREEN_REGISTER_DISTRIBUTED_LABEL, DSCREEN_REGISTER_DISTRIBUTED_START);
     std::string version = param.version;
     std::string attrs = param.attrs;
     DHLOGD("enable distributedScreen. devId: %s, dhId: %s, reqId: %s, attrs: %s, version: %s",
@@ -110,6 +115,7 @@ int32_t DScreenSourceService::RegisterDistributedHardware(const std::string &dev
             GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), reqId.c_str(), attrs.c_str());
         return ERR_DH_SCREEN_SA_ENABLE_FAILED;
     }
+    FinishTrace(DSCREEN_REGISTER_DISTRIBUTED_LABEL);
     return DH_SUCCESS;
 }
 
@@ -117,12 +123,14 @@ int32_t DScreenSourceService::UnregisterDistributedHardware(const std::string &d
     const std::string &reqId)
 {
     DHLOGI("UnregisterDistributedHardware");
+    StartTrace(DSCREEN_UNREGISTER_DISTRIBUTED_LABEL, DSCREEN_UNREGISTER_DISTRIBUTED_START);
     int ret = DScreenManager::GetInstance().DisableDistributedScreen(devId, dhId, reqId);
     if (ret != DH_SUCCESS) {
         DHLOGE("disable distributedScreen failed. devId: %s, dhId: %s, reqId: %s",
             GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), reqId.c_str());
         return ERR_DH_SCREEN_SA_DISABLE_FAILED;
     }
+    FinishTrace(DSCREEN_UNREGISTER_DISTRIBUTED_LABEL);
     return DH_SUCCESS;
 }
 
diff --git a/services/screentransport/screendatachannel/src/screen_data_channel_impl.cpp b/services/screentransport/screendatachannel/src/screen_data_channel_impl.cpp
index 6097c4a5c64a91659f96305bb884e29a6632358e..f3484ef84d14e7f503fcd16b6fba974e49552049 100644
--- a/services/screentransport/screendatachannel/src/screen_data_channel_impl.cpp
+++ b/services/screentransport/screendatachannel/src/screen_data_channel_impl.cpp
@@ -19,6 +19,7 @@
 
 #include "dscreen_constants.h"
 #include "dscreen_errcode.h"
+#include "dscreen_hitrace.h"
 #include "dscreen_log.h"
 #include "dscreen_util.h"
 
@@ -26,6 +27,7 @@ namespace OHOS {
 namespace DistributedHardware {
 int32_t ScreenDataChannelImpl::CreateSession(const std::shared_ptr<IScreenChannelListener> &listener)
 {
+    StartTrace(DSCREEN_CREAT_SESSION_LABEL, DSCREEN_CREAT_SESSION_START);
     DHLOGI("%s: CreateSession, peerDevId(%s)", LOG_TAG, GetAnonyString(peerDevId_).c_str());
     if (!listener) {
         DHLOGE("%s: Channel listener is null", LOG_TAG);
@@ -48,11 +50,13 @@ int32_t ScreenDataChannelImpl::CreateSession(const std::shared_ptr<IScreenChanne
 
     channelListener_ = listener;
     DHLOGI("%s: Create softbus session success.", LOG_TAG);
+    FinishTrace(DSCREEN_CREAT_SESSION_LABEL);
     return DH_SUCCESS;
 }
 
 int32_t ScreenDataChannelImpl::ReleaseSession()
 {
+    StartTrace(DSCREEN_RELEASE_SESSION_LABEL, DSCREEN_RELEASE_SESSION_START);
     DHLOGI("%s: ReleaseSession, peerDevId(%s)", LOG_TAG, GetAnonyString(peerDevId_).c_str());
     int32_t ret = SoftbusAdapter::GetInstance().RemoveSoftbusSessionServer(PKG_NAME, DATA_SESSION_NAME, peerDevId_);
     if (ret != DH_SUCCESS) {
@@ -67,11 +71,13 @@ int32_t ScreenDataChannelImpl::ReleaseSession()
     }
 
     DHLOGI("%s: Release softbus session success.", LOG_TAG);
+    FinishTrace(DSCREEN_RELEASE_SESSION_LABEL);
     return DH_SUCCESS;
 }
 
 int32_t ScreenDataChannelImpl::OpenSession()
 {
+    StartTrace(DSCREEN_OPEN_SESSION_LABEL, DSCREEN_OPEN_SESSION_START);
     DHLOGI("%s: OpenSession, peerDevId(%s)", LOG_TAG, GetAnonyString(peerDevId_).c_str());
     int32_t sessionId =
         SoftbusAdapter::GetInstance().OpenSoftbusSession(DATA_SESSION_NAME, DATA_SESSION_NAME, peerDevId_);
@@ -82,11 +88,13 @@ int32_t ScreenDataChannelImpl::OpenSession()
     sessionId_ = sessionId;
 
     DHLOGI("%s: Open screen session success, sessionId(%d)", LOG_TAG, sessionId_);
+    FinishTrace(DSCREEN_OPEN_SESSION_LABEL);
     return DH_SUCCESS;
 }
 
 int32_t ScreenDataChannelImpl::CloseSession()
 {
+    StartTrace(DSCREEN_CLOSE_SESSION_LABEL, DSCREEN_CLOSE_SESSION_START);
     DHLOGI("%s: CloseSession, sessionId(%d)", LOG_TAG, sessionId_);
     if (sessionId_ == 0) {
         DHLOGD("%s: Session is not opened.", LOG_TAG);
@@ -101,11 +109,13 @@ int32_t ScreenDataChannelImpl::CloseSession()
     sessionId_ = 0;
 
     DHLOGI("%s: Close screen session success.", LOG_TAG);
+    FinishTrace(DSCREEN_CLOSE_SESSION_LABEL);
     return DH_SUCCESS;
 }
 
 int32_t ScreenDataChannelImpl::SendData(const std::shared_ptr<DataBuffer> &screenData)
 {
+    StartTrace(DSCREEN_SEND_DATA_LABEL, DSCREEN_SEND_DATA_START);
     DHLOGD("%s: SendData, sessionId(%d)", LOG_TAG, sessionId_);
     if (!screenData) {
         DHLOGE("%s: Screen data is null", LOG_TAG);
@@ -122,11 +132,13 @@ int32_t ScreenDataChannelImpl::SendData(const std::shared_ptr<DataBuffer> &scree
         return ret;
     }
 
+    FinishTrace(DSCREEN_SEND_DATA_LABEL);
     return DH_SUCCESS;
 }
 
 void ScreenDataChannelImpl::OnSessionOpened(int32_t sessionId, int32_t result)
 {
+    StartTrace(DSCREEN_ON_SESSION_OPEN_LABEL, DSCREEN_ON_SESSION_OPEN_START);
     DHLOGI("%s: OnScreenSessionOpened, sessionId: %d, result: %d", LOG_TAG, sessionId, result);
     if (result != 0) {
         DHLOGE("Session open failed.", LOG_TAG);
@@ -140,10 +152,12 @@ void ScreenDataChannelImpl::OnSessionOpened(int32_t sessionId, int32_t result)
     }
     listener->OnSessionOpened();
     sessionId_ = sessionId;
+    FinishTrace(DSCREEN_ON_SESSION_OPEN_LABEL);
 }
 
 void ScreenDataChannelImpl::OnSessionClosed(int32_t sessionId)
 {
+    StartTrace(DSCREEN_ON_SESSION_CLOSE_LABEL, DSCREEN_ON_SESSION_CLOSE_START);
     DHLOGI("%s: OnScreenSessionClosed, sessionId(%d).", LOG_TAG, sessionId);
     std::shared_ptr<IScreenChannelListener> listener = channelListener_.lock();
     if (!listener) {
@@ -151,6 +165,7 @@ void ScreenDataChannelImpl::OnSessionClosed(int32_t sessionId)
         return;
     }
     listener->OnSessionClosed();
+    FinishTrace(DSCREEN_ON_SESSION_CLOSE_LABEL);
 }
 
 void ScreenDataChannelImpl::OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen)
@@ -165,6 +180,7 @@ void ScreenDataChannelImpl::OnBytesReceived(int32_t sessionId, const void *data,
 void ScreenDataChannelImpl::OnStreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext,
     const StreamFrameInfo *param)
 {
+    StartTrace(DSCREEN_ON_STREAM_RECEIVED_LABEL, DSCREEN_ON_STREAM_RECEIVED_START);
     (void)ext;
     (void)param;
 
@@ -192,6 +208,7 @@ void ScreenDataChannelImpl::OnStreamReceived(int32_t sessionId, const StreamData
         return;
     }
     listener->OnDataReceived(dataBuffer);
+    FinishTrace(DSCREEN_ON_STREAM_RECEIVED_LABEL);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/screentransport/screensinkprocessor/decoder/src/image_decoder_callback.cpp b/services/screentransport/screensinkprocessor/decoder/src/image_decoder_callback.cpp
index b19fb8708670905c20ec4fa4da4349283ef148c9..05a8dfb29fbf5a10c38afd2b32753986ba52550b 100644
--- a/services/screentransport/screensinkprocessor/decoder/src/image_decoder_callback.cpp
+++ b/services/screentransport/screensinkprocessor/decoder/src/image_decoder_callback.cpp
@@ -22,6 +22,7 @@ namespace OHOS {
 namespace DistributedHardware {
 void ImageDecoderCallback::OnError(Media::AVCodecErrorType errorType, int32_t errorCode)
 {
+    StartTrace(DSCREEN_IMAGE_DECODER_CALLBACK_LABEL, DSCREEN_IMAGE_DECODER_CALLBACK_START);
     DHLOGD("%s: OnError.", LOG_TAG);
     std::shared_ptr<ImageSinkDecoder> decoder = videoDecoder_.lock();
     if (decoder == nullptr) {
@@ -29,11 +30,13 @@ void ImageDecoderCallback::OnError(Media::AVCodecErrorType errorType, int32_t er
         return;
     }
     decoder->OnError(errorType, errorCode);
+    FinishTrace(DSCREEN_IMAGE_DECODER_CALLBACK_LABEL);
 }
 
 void ImageDecoderCallback::OnOutputBufferAvailable(uint32_t index, Media::AVCodecBufferInfo info,
     Media::AVCodecBufferFlag flag)
 {
+    StartTrace(DSCREEN_ON_OUTPUT_BUFFER_LABEL, DSCREEN_ON_OUTPUT_BUFFER_START);
     DHLOGD("%s: OnOutputBufferAvailable.", LOG_TAG);
     std::shared_ptr<ImageSinkDecoder> decoder = videoDecoder_.lock();
     if (decoder == nullptr) {
@@ -41,10 +44,12 @@ void ImageDecoderCallback::OnOutputBufferAvailable(uint32_t index, Media::AVCode
         return;
     }
     decoder->OnOutputBufferAvailable(index, info, flag);
+    FinishTrace(DSCREEN_ON_OUTPUT_BUFFER_LABEL);
 }
 
 void ImageDecoderCallback::OnInputBufferAvailable(uint32_t index)
 {
+    StartTrace(DSCREEN_ONINPUT_BUFFER_LABEL, DSCREEN_ONINPUT_BUFFER_START);
     DHLOGD("%s: OnInputBufferAvailable.", LOG_TAG);
     std::shared_ptr<ImageSinkDecoder> decoder = videoDecoder_.lock();
     if (decoder == nullptr) {
@@ -52,10 +57,12 @@ void ImageDecoderCallback::OnInputBufferAvailable(uint32_t index)
         return;
     }
     decoder->OnInputBufferAvailable(index);
+    FinishTrace(DSCREEN_ONINPUT_BUFFER_LABEL);
 }
 
 void ImageDecoderCallback::OnOutputFormatChanged(const Media::Format &format)
 {
+    StartTrace(DSCREEN_ON_OUTPUT_FORMAT_LABEL, DSCREEN_ON_OUTPUT_FORMAT_START);
     DHLOGD("%s: OnOutputFormatChanged.", LOG_TAG);
     std::shared_ptr<ImageSinkDecoder> decoder = videoDecoder_.lock();
     if (decoder == nullptr) {
@@ -63,6 +70,7 @@ void ImageDecoderCallback::OnOutputFormatChanged(const Media::Format &format)
         return;
     }
     decoder->OnOutputFormatChanged(format);
+    FinishTrace(DSCREEN_ON_OUTPUT_FORMAT_LABEL);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp b/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp
index a210198fe81a49f336b7f99b462c9620cf13ff2e..6f5d65434b9fdf75876d88e02a677db7062b0f06 100644
--- a/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp
+++ b/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp
@@ -279,7 +279,9 @@ int32_t ImageSinkDecoder::StopInputThread()
 {
     DHLOGI("%s: StopInputThread.", LOG_TAG);
     isDecoderReady_ = false;
-    decodeThread_.join();
+    if (decodeThread_.joinable()) {
+        decodeThread_.join();
+    }
     std::lock_guard<std::mutex> dataLock(dataMutex_);
     while (!bufferIndexQueue_.empty()) {
         bufferIndexQueue_.pop();
diff --git a/services/screentransport/screensourcetrans/src/screen_source_trans.cpp b/services/screentransport/screensourcetrans/src/screen_source_trans.cpp
index 6d2ef574b8f5b7ba7ce236ffcb639be1c1e0da7f..0d0133e97b6f65d4fb71ee4e2c03535458e4ef0c 100644
--- a/services/screentransport/screensourcetrans/src/screen_source_trans.cpp
+++ b/services/screentransport/screensourcetrans/src/screen_source_trans.cpp
@@ -121,7 +121,9 @@ int32_t ScreenSourceTrans::Stop()
         stopStatus = false;
     }
     isChannelReady_ = false;
-    sendDataThread_.join();
+    if (sendDataThread_.joinable()) {
+        sendDataThread_.join();
+    }
 
     if (!stopStatus) {
         DHLOGE("%s: Stop source trans failed.", LOG_TAG);
@@ -309,7 +311,9 @@ void ScreenSourceTrans::OnSessionClosed()
 {
     DHLOGI("%s: OnChannelSessionClosed.", LOG_TAG);
     isChannelReady_ = false;
-    sendDataThread_.join();
+    if (sendDataThread_.joinable()) {
+        sendDataThread_.join();
+    }
 
     std::shared_ptr<IScreenSourceTransCallback> callback = transCallback_.lock();
     if (!callback) {