diff --git a/interfaces/kits/napi/embeddable_window_stage/js_embeddable_window_stage.cpp b/interfaces/kits/napi/embeddable_window_stage/js_embeddable_window_stage.cpp
index fa2c5ec64c54a4112778cf21b68c82b92a6e4e1b..9696cde96a0e7bda3fe615fd994dc6ea6a2ffd3e 100644
--- a/interfaces/kits/napi/embeddable_window_stage/js_embeddable_window_stage.cpp
+++ b/interfaces/kits/napi/embeddable_window_stage/js_embeddable_window_stage.cpp
@@ -24,9 +24,6 @@
 namespace OHOS {
 namespace Rosen {
 using namespace AbilityRuntime;
-namespace {
-constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsEmbeddableWindowStage"};
-} // namespace
 
 JsEmbeddableWindowStage::JsEmbeddableWindowStage(sptr<Rosen::Window> window, sptr<AAFwk::SessionInfo> sessionInfo)
     : windowExtensionSessionImpl_(window), sessionInfo_(sessionInfo),
@@ -40,62 +37,62 @@ JsEmbeddableWindowStage::~JsEmbeddableWindowStage()
 
 void JsEmbeddableWindowStage::Finalizer(napi_env env, void* data, void* hint)
 {
-    WLOGI("[NAPI]Finalizer");
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Finalizer");
     std::unique_ptr<JsEmbeddableWindowStage>(static_cast<JsEmbeddableWindowStage*>(data));
 }
 
 napi_value JsEmbeddableWindowStage::GetMainWindow(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]GetMainWindow");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]GetMainWindow");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnGetMainWindow(env, info) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::GetMainWindowSync(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]GetMainWindowSync");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]GetMainWindowSync");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnGetMainWindowSync(env, info) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::On(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]On");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]On");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnEvent(env, info) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::Off(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]Off");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]Off");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OffEvent(env, info) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::LoadContent(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]LoadContent");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]LoadContent");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnLoadContent(env, info, false) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::LoadContentByName(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]LoadContentByName");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]LoadContentByName");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnLoadContent(env, info, true) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::CreateSubWindow(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]CreateSubWindow");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]CreateSubWindow");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnCreateSubWindow(env, info) : nullptr;
 }
 
 napi_value JsEmbeddableWindowStage::GetSubWindow(napi_env env, napi_callback_info info)
 {
-    WLOGFD("[NAPI]GetSubWindow");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]GetSubWindow");
     JsEmbeddableWindowStage* me = CheckParamsAndGetThis<JsEmbeddableWindowStage>(env, info);
     return (me != nullptr) ? me->OnGetSubWindow(env, info) : nullptr;
 }
@@ -143,7 +140,7 @@ napi_value JsEmbeddableWindowStage::OnGetMainWindow(napi_env env, napi_callback_
             if (windowImpl != nullptr) {
                 task.Resolve(env, Rosen::JsExtensionWindow::CreateJsExtensionWindowObject(env,
                 windowImpl, sessionInfo));
-                WLOGI("[NAPI]Get main window [%{public}u, %{public}s]",
+                TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Get main window [%{public}u, %{public}s]",
                     windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str());
             } else {
                 task.Reject(env, CreateJsError(env,
@@ -165,7 +162,7 @@ napi_value JsEmbeddableWindowStage::OnGetMainWindow(napi_env env, napi_callback_
 napi_value JsEmbeddableWindowStage::OnGetMainWindowSync(napi_env env, napi_callback_info info)
 {
     if (windowExtensionSessionImpl_ == nullptr) {
-        WLOGFE("[NAPI]window is null");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]window is null");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
         return NapiGetUndefined(env);
     }
@@ -178,14 +175,14 @@ napi_value JsEmbeddableWindowStage::OnEvent(napi_env env, napi_callback_info inf
 {
     sptr<Window> windowImpl = windowExtensionSessionImpl_;
     if (windowImpl == nullptr) {
-        WLOGFE("[NAPI]windowImpl is null");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]windowImpl is null");
         return NapiGetUndefined(env);
     }
     size_t argc = 4;
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (argc < 2) { // 2: minimum param nums
-        WLOGFE("[NAPI]argc is invalid: %{public}zu", argc);
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]argc is invalid: %{public}zu", argc);
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -193,13 +190,13 @@ napi_value JsEmbeddableWindowStage::OnEvent(napi_env env, napi_callback_info inf
     // Parse argv[0] as string
     std::string eventString;
     if (!ConvertFromJsValue(env, argv[0], eventString)) {
-        WLOGFE("[NAPI]Failed to convert parameter to string");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Failed to convert parameter to string");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
     napi_value value = argv[1];
     if (!NapiIsCallable(env, value)) {
-        WLOGFE("[NAPI]Callback(argv[1]) is not callable");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Callback(argv[1]) is not callable");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -207,10 +204,10 @@ napi_value JsEmbeddableWindowStage::OnEvent(napi_env env, napi_callback_info inf
     WmErrorCode ret = extwinRegisterManager_->RegisterListener(windowImpl, eventString,
         CaseType::CASE_STAGE, env, value);
     if (ret != WmErrorCode::WM_OK) {
-        WLOGFE("[NAPI]RegisterListener fail");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]RegisterListener fail");
         return NapiThrowError(env, ret);
     }
-    WLOGI("[NAPI]Window [%{public}u, %{public}s] register event %{public}s",
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Window [%{public}u, %{public}s] register event %{public}s",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), eventString.c_str());
 
     return NapiGetUndefined(env);
@@ -220,7 +217,7 @@ napi_value JsEmbeddableWindowStage::OffEvent(napi_env env, napi_callback_info in
 {
     sptr<Window> windowImpl = windowExtensionSessionImpl_;
     if (windowImpl == nullptr) {
-        WLOGFE("[NAPI]windowImpl is null");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]windowImpl is null");
         return NapiGetUndefined(env);
     }
     size_t argc = 4;
@@ -229,12 +226,12 @@ napi_value JsEmbeddableWindowStage::OffEvent(napi_env env, napi_callback_info in
     // Parse argv[0] as string
     std::string eventString;
     if (!ConvertFromJsValue(env, argv[0], eventString)) {
-        WLOGFE("[NAPI]Failed to convert parameter to string");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Failed to convert parameter to string");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
     if (eventString.compare("windowStageEvent") != 0) {
-        WLOGFE("[NAPI]Envent %{public}s is invalid", eventString.c_str());
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Envent %{public}s is invalid", eventString.c_str());
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -253,10 +250,10 @@ napi_value JsEmbeddableWindowStage::OffEvent(napi_env env, napi_callback_info in
         }
     }
     if (ret != WmErrorCode::WM_OK) {
-        WLOGFE("[NAPI]UnregisterListener fail");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]UnregisterListener fail");
         return NapiThrowError(env, ret);
     }
-    WLOGI("[NAPI]Window [%{public}u, %{public}s] unregister event %{public}s",
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Window [%{public}u, %{public}s] unregister event %{public}s",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), eventString.c_str());
 
     return NapiGetUndefined(env);
@@ -278,7 +275,7 @@ static void LoadContentTask(std::shared_ptr<NativeReference> contentStorage, std
     } else {
         task.Reject(env, CreateJsError(env, static_cast<int32_t>(ret), "Window load content failed"));
     }
-    WLOGI("[NAPI]Window [%{public}u, %{public}s] load content end, ret = %{public}d",
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Window [%{public}u, %{public}s] load content end, ret = %{public}d",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), ret);
     return;
 }
@@ -291,7 +288,7 @@ napi_value JsEmbeddableWindowStage::OnLoadContent(napi_env env, napi_callback_in
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (!ConvertFromJsValue(env, argv[0], contextUrl)) {
-        WLOGFE("[NAPI]Failed to convert parameter to context url");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Failed to convert parameter to context url");
         errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
     }
     napi_value storage = nullptr;
@@ -307,7 +304,7 @@ napi_value JsEmbeddableWindowStage::OnLoadContent(napi_env env, napi_callback_in
         callBack = value2;
     }
     if (errCode == WmErrorCode::WM_ERROR_INVALID_PARAM) {
-        WLOGFE("[NAPI]Window scene is null or get invalid param");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Window scene is null or get invalid param");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -325,7 +322,7 @@ napi_value JsEmbeddableWindowStage::OnLoadContent(napi_env env, napi_callback_in
             napi_env env, NapiAsyncTask& task, int32_t status) {
             if (window == nullptr) {
                 task.Reject(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
-                WLOGFE("[NAPI]Get windowExtensionSessionImpl failed");
+                TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Get windowExtensionSessionImpl failed");
                 return;
             }
             LoadContentTask(contentStorage, contextUrl, window, env, task, parentToken, isLoadedByName);
@@ -339,7 +336,7 @@ napi_value JsEmbeddableWindowStage::OnLoadContent(napi_env env, napi_callback_in
 napi_value JsEmbeddableWindowStage::CreateJsEmbeddableWindowStage(napi_env env, sptr<Rosen::Window> window,
     sptr<AAFwk::SessionInfo> sessionInfo)
 {
-    WLOGFD("[NAPI]CreateJsEmbeddableWindowStage");
+    TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]CreateJsEmbeddableWindowStage");
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
 
diff --git a/interfaces/kits/napi/extension_window/js_extension_window.cpp b/interfaces/kits/napi/extension_window/js_extension_window.cpp
index e7078a3e1942bca140aa0af1d044d6ecfab2fb49..d4a4e3886d1ad870b921b8e79a466abf2e202753 100644
--- a/interfaces/kits/napi/extension_window/js_extension_window.cpp
+++ b/interfaces/kits/napi/extension_window/js_extension_window.cpp
@@ -28,7 +28,6 @@ namespace OHOS {
 namespace Rosen {
 using namespace AbilityRuntime;
 namespace {
-constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsExtensionWindow"};
 constexpr Rect g_emptyRect = {0, 0, 0, 0};
 } // namespace
 
@@ -49,12 +48,12 @@ JsExtensionWindow::~JsExtensionWindow() {}
 
 napi_value JsExtensionWindow::CreateJsExtensionWindow(napi_env env, sptr<Rosen::Window> window, int32_t hostWindowId)
 {
-    WLOGI("JsExtensionWindow CreateJsExtensionWindow");
+    TLOGI(WmsLogTag::WMS_UIEXT, "JsExtensionWindow CreateJsExtensionWindow");
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
 
     if (env == nullptr || window == nullptr) {
-        WLOGFE("JsExtensionWindow env or window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "JsExtensionWindow env or window is nullptr");
         return nullptr;
     }
 
@@ -83,12 +82,12 @@ napi_value JsExtensionWindow::CreateJsExtensionWindow(napi_env env, sptr<Rosen::
 napi_value JsExtensionWindow::CreateJsExtensionWindowObject(napi_env env, sptr<Rosen::Window> window,
     sptr<AAFwk::SessionInfo> sessionInfo)
 {
-    WLOGI("JsExtensionWindow CreateJsExtensionWindow");
+    TLOGI(WmsLogTag::WMS_UIEXT, "JsExtensionWindow CreateJsExtensionWindow");
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
 
     if (env == nullptr || window == nullptr) {
-        WLOGFE("JsExtensionWindow env or window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "JsExtensionWindow env or window is nullptr");
         return nullptr;
     }
 
@@ -126,41 +125,41 @@ napi_value JsExtensionWindow::CreateJsExtensionWindowObject(napi_env env, sptr<R
 
 void JsExtensionWindow::Finalizer(napi_env env, void* data, void* hint)
 {
-    WLOGI("Finalizer is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "Finalizer is called");
     std::unique_ptr<JsExtensionWindow>(static_cast<JsExtensionWindow*>(data));
 }
 
 napi_value JsExtensionWindow::GetWindowAvoidArea(napi_env env, napi_callback_info info)
 {
-    WLOGI("GetWindowAvoidArea is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "GetWindowAvoidArea is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnGetWindowAvoidArea(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::RegisterExtensionWindowCallback(napi_env env, napi_callback_info info)
 {
-    WLOGI("RegisterExtensionWindowCallback is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "RegisterExtensionWindowCallback is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnRegisterExtensionWindowCallback(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::UnRegisterExtensionWindowCallback(napi_env env, napi_callback_info info)
 {
-    WLOGI("UnRegisterExtensionWindowCallback is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "UnRegisterExtensionWindowCallback is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnUnRegisterExtensionWindowCallback(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::HideNonSecureWindows(napi_env env, napi_callback_info info)
 {
-    WLOGI("HideNonSecureWindows is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "HideNonSecureWindows is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnHideNonSecureWindows(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::CreateSubWindowWithOptions(napi_env env, napi_callback_info info)
 {
-    WLOGI("CreateSubWindowWithOptions is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "CreateSubWindowWithOptions is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnCreateSubWindowWithOptions(env, info) : nullptr;
 }
@@ -174,112 +173,112 @@ napi_value JsExtensionWindow::SetWaterMarkFlag(napi_env env, napi_callback_info
 
 napi_value JsExtensionWindow::LoadContent(napi_env env, napi_callback_info info)
 {
-    WLOGI("LoadContent is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "LoadContent is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnLoadContent(env, info, false) : nullptr;
 }
 
 napi_value JsExtensionWindow::LoadContentByName(napi_env env, napi_callback_info info)
 {
-    WLOGI("LoadContentByName is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "LoadContentByName is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnLoadContent(env, info, true) : nullptr;
 }
 
 napi_value JsExtensionWindow::ShowWindow(napi_env env, napi_callback_info info)
 {
-    WLOGI("ShowWindow is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "ShowWindow is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnShowWindow(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::IsWindowShowingSync(napi_env env, napi_callback_info info)
 {
-    WLOGI("IsShowing is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "IsShowing is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnIsWindowShowingSync(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetUIContent(napi_env env, napi_callback_info info)
 {
-    WLOGI("LoadContent is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "LoadContent is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetUIContent(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::DestroyWindow(napi_env env, napi_callback_info info)
 {
-    WLOGI("Destroy is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "Destroy is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnDestroyWindow(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetWindowBackgroundColorSync(napi_env env, napi_callback_info info)
 {
-    WLOGI("SetBackgroundColor is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "SetBackgroundColor is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetWindowBackgroundColorSync(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::GetWindowPropertiesSync(napi_env env, napi_callback_info info)
 {
-    WLOGD("GetProperties is called");
+    TLOGD(WmsLogTag::WMS_UIEXT, "GetProperties is called");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnGetWindowPropertiesSync(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::MoveWindowTo(napi_env env, napi_callback_info info)
 {
-    WLOGD("MoveTo");
+    TLOGD(WmsLogTag::WMS_UIEXT, "MoveTo");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnMoveWindowTo(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::ResizeWindow(napi_env env, napi_callback_info info)
 {
-    WLOGI("Resize");
+    TLOGI(WmsLogTag::WMS_UIEXT, "Resize");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnResizeWindow(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetSpecificSystemBarEnabled(napi_env env, napi_callback_info info)
 {
-    WLOGI("SetSystemBarEnable");
+    TLOGI(WmsLogTag::WMS_UIEXT, "SetSystemBarEnable");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetSpecificSystemBarEnabled(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetPreferredOrientation(napi_env env, napi_callback_info info)
 {
-    WLOGD("SetPreferredOrientation");
+    TLOGD(WmsLogTag::WMS_UIEXT, "SetPreferredOrientation");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetPreferredOrientation(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::GetPreferredOrientation(napi_env env, napi_callback_info info)
 {
-    WLOGD("GetPreferredOrientation");
+    TLOGD(WmsLogTag::WMS_UIEXT, "GetPreferredOrientation");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnGetPreferredOrientation(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::GetUIContext(napi_env env, napi_callback_info info)
 {
-    WLOGD("GetUIContext");
+    TLOGD(WmsLogTag::WMS_UIEXT, "GetUIContext");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnGetUIContext(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetWindowBrightness(napi_env env, napi_callback_info info)
 {
-    WLOGI("SetBrightness");
+    TLOGI(WmsLogTag::WMS_UIEXT, "SetBrightness");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetWindowBrightness(env, info) : nullptr;
 }
 
 napi_value JsExtensionWindow::SetWindowKeepScreenOn(napi_env env, napi_callback_info info)
 {
-    WLOGI("SetKeepScreenOn");
+    TLOGI(WmsLogTag::WMS_UIEXT, "SetKeepScreenOn");
     JsExtensionWindow* me = CheckParamsAndGetThis<JsExtensionWindow>(env, info);
     return (me != nullptr) ? me->OnSetWindowKeepScreenOn(env, info) : nullptr;
 }
@@ -308,7 +307,7 @@ static void LoadContentTask(std::shared_ptr<NativeReference> contentStorage, std
     } else {
         task.Reject(env, CreateJsError(env, static_cast<int32_t>(ret), "Window load content failed"));
     }
-    WLOGI("Window [%{public}u, %{public}s] load content end, ret = %{public}d",
+    TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] load content end, ret = %{public}d",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), ret);
     return;
 }
@@ -434,11 +433,11 @@ napi_value JsExtensionWindow::OnGetWindowPropertiesSync(napi_env env, napi_callb
 {
     sptr<Window> windowImpl = extensionWindow_->GetWindow();
     if (windowImpl == nullptr) {
-        WLOGFW("window is nullptr or get invalid param");
+        TLOGW(WmsLogTag::WMS_UIEXT, "window is nullptr or get invalid param");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     auto objValue = CreateJsExtensionWindowProperties(env, windowImpl);
-    WLOGI("Window [%{public}u, %{public}s] get properties end",
+    TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] get properties end",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str());
     if (objValue != nullptr) {
         return objValue;
@@ -457,20 +456,20 @@ napi_value JsExtensionWindow::OnDestroyWindow(napi_env env, napi_callback_info i
     NapiAsyncTask::CompleteCallback complete =
         [this, extwin = extensionWindow_](napi_env env, NapiAsyncTask& task, int32_t status) {
             if (extwin == nullptr) {
-                WLOGFE("extensionWindow is null");
+                TLOGE(WmsLogTag::WMS_UIEXT, "extensionWindow is null");
                 task.Reject(env,
                     CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
                 return;
             }
             sptr<Window> windowImpl = extwin->GetWindow();
             if (windowImpl == nullptr) {
-                WLOGFE("window is nullptr or get invalid param");
+                TLOGE(WmsLogTag::WMS_UIEXT, "window is nullptr or get invalid param");
                 task.Reject(env,
                     CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
                 return;
             }
             WmErrorCode ret = WM_JS_TO_ERROR_CODE_MAP.at(windowImpl->Destroy());
-            WLOGI("Window [%{public}u, %{public}s] destroy end, ret = %{public}d",
+            TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] destroy end, ret = %{public}d",
                 windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), ret);
             if (ret != WmErrorCode::WM_OK) {
                 task.Reject(env,
@@ -496,11 +495,11 @@ napi_value JsExtensionWindow::OnIsWindowShowingSync(napi_env env, napi_callback_
 {
     sptr<Window> windowImpl = extensionWindow_->GetWindow();
     if (windowImpl == nullptr) {
-        WLOGFE("window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "window is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     bool state = (windowImpl->GetWindowState() == WindowState::STATE_SHOWN);
-    WLOGI("Window [%{public}u, %{public}s] get show state end, state = %{public}u",
+    TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] get show state end, state = %{public}u",
         windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), state);
     return CreateJsValue(env, state);
 }
@@ -510,7 +509,7 @@ napi_value JsExtensionWindow::OnShowWindow(napi_env env, napi_callback_info info
     NapiAsyncTask::CompleteCallback complete =
         [extwin = extensionWindow_](napi_env env, NapiAsyncTask& task, int32_t status) {
             if (extwin == nullptr) {
-                WLOGFE("extensionWindow is null");
+                TLOGE(WmsLogTag::WMS_UIEXT, "extensionWindow is null");
                 task.Reject(env, CreateJsError(env,
                     static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
                 return;
@@ -519,11 +518,11 @@ napi_value JsExtensionWindow::OnShowWindow(napi_env env, napi_callback_info info
             if (windowImpl == nullptr) {
                 task.Reject(env, CreateJsError(env,
                     static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
-                WLOGFE("window is nullptr or get invalid param");
+                TLOGE(WmsLogTag::WMS_UIEXT, "window is nullptr or get invalid param");
                 return;
             }
             WMError ret = windowImpl->Show(0, false);
-            WLOGI("Window [%{public}u, %{public}s] show with ret = %{public}d",
+            TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] show with ret = %{public}d",
                 windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), ret);
             if (ret == WMError::WM_OK) {
                 task.Resolve(env, NapiGetUndefined(env));
@@ -531,7 +530,7 @@ napi_value JsExtensionWindow::OnShowWindow(napi_env env, napi_callback_info info
                 task.Reject(env, CreateJsError(env,
                     static_cast<int32_t>(WM_JS_TO_ERROR_CODE_MAP.at(ret)), "Window show failed"));
             }
-            WLOGI("Window [%{public}u, %{public}s] show end, ret = %{public}d",
+            TLOGI(WmsLogTag::WMS_UIEXT, "Window [%{public}u, %{public}s] show end, ret = %{public}d",
                 windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), ret);
         };
     napi_value result = nullptr;
@@ -552,12 +551,12 @@ napi_value JsExtensionWindow::OnSetUIContent(napi_env env, napi_callback_info in
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (argc < 1) { // 2 maximum param num
-        WLOGFE("Argc is invalid: %{public}zu", argc);
+        TLOGE(WmsLogTag::WMS_UIEXT, "Argc is invalid: %{public}zu", argc);
         errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
     }
     std::string contextUrl;
     if (errCode == WmErrorCode::WM_OK && !ConvertFromJsValue(env, argv[0], contextUrl)) {
-        WLOGFE("Failed to convert parameter to context url");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert parameter to context url");
         errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
     }
     napi_value callBack = nullptr;
@@ -574,7 +573,7 @@ napi_value JsExtensionWindow::OnSetUIContent(napi_env env, napi_callback_info in
         [extwin = extensionWindow_, contentStorage, contextUrl, parentToken]
         (napi_env env, NapiAsyncTask& task, int32_t status) {
             if (extwin == nullptr) {
-                WLOGFE("Window is nullptr");
+                TLOGE(WmsLogTag::WMS_UIEXT, "Window is nullptr");
                 task.Reject(env,
                     CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
                 return;
@@ -589,14 +588,14 @@ napi_value JsExtensionWindow::OnSetUIContent(napi_env env, napi_callback_info in
 
 napi_value JsExtensionWindow::OnLoadContent(napi_env env, napi_callback_info info, bool isLoadedByName)
 {
-    WLOGI("OnLoadContent is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "OnLoadContent is called");
     WmErrorCode errCode = WmErrorCode::WM_OK;
     size_t argc = 4;
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     std::string contextUrl;
     if (!ConvertFromJsValue(env, argv[0], contextUrl)) {
-        WLOGI("Failed to convert parameter to context url");
+        TLOGI(WmsLogTag::WMS_UIEXT, "Failed to convert parameter to context url");
         errCode = WmErrorCode::WM_ERROR_INVALID_PARAM;
     }
     napi_value storage = nullptr;
@@ -612,7 +611,7 @@ napi_value JsExtensionWindow::OnLoadContent(napi_env env, napi_callback_info inf
         callBack = value2;
     }
     if (errCode == WmErrorCode::WM_ERROR_INVALID_PARAM) {
-        WLOGI("Window is null or get invalid param");
+        TLOGI(WmsLogTag::WMS_UIEXT, "Window is null or get invalid param");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -629,7 +628,7 @@ napi_value JsExtensionWindow::OnLoadContent(napi_env env, napi_callback_info inf
         [extwin = extensionWindow_, contentStorage, contextUrl, parentToken, isLoadedByName](
             napi_env env, NapiAsyncTask& task, int32_t status) {
             if (extwin == nullptr) {
-                WLOGFE("Window is nullptr or get invalid param");
+                TLOGE(WmsLogTag::WMS_UIEXT, "Window is nullptr or get invalid param");
                 task.Reject(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STATE_ABNORMALLY)));
                 return;
             }
@@ -643,7 +642,7 @@ napi_value JsExtensionWindow::OnLoadContent(napi_env env, napi_callback_info inf
 
 napi_value JsExtensionWindow::OnGetWindowAvoidArea(napi_env env, napi_callback_info info)
 {
-    WLOGI("OnGetWindowAvoidArea is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "OnGetWindowAvoidArea is called");
 
     WmErrorCode errCode = WmErrorCode::WM_OK;
     size_t argc = 4;
@@ -669,7 +668,7 @@ napi_value JsExtensionWindow::OnGetWindowAvoidArea(napi_env env, napi_callback_i
     }
 
     if (extensionWindow_ == nullptr) {
-        WLOGFE("extensionWindow_ is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "extensionWindow_ is nullptr");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STAGE_ABNORMALLY)));
         return CreateJsValue(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_STAGE_ABNORMALLY));
     }
@@ -677,7 +676,7 @@ napi_value JsExtensionWindow::OnGetWindowAvoidArea(napi_env env, napi_callback_i
     AvoidArea avoidArea;
     WmErrorCode ret = WM_JS_TO_ERROR_CODE_MAP.at(extensionWindow_->GetAvoidAreaByType(avoidAreaType, avoidArea));
     if (ret != WmErrorCode::WM_OK) {
-        WLOGFE("OnGetAvoidAreaByType failed");
+        TLOGE(WmsLogTag::WMS_UIEXT, "OnGetAvoidAreaByType failed");
         avoidArea.topRect_ = g_emptyRect;
         avoidArea.leftRect_ = g_emptyRect;
         avoidArea.rightRect_ = g_emptyRect;
@@ -685,10 +684,10 @@ napi_value JsExtensionWindow::OnGetWindowAvoidArea(napi_env env, napi_callback_i
     }
     napi_value avoidAreaObj = ConvertAvoidAreaToJsValue(env, avoidArea, avoidAreaType);
     if (avoidAreaObj != nullptr) {
-        WLOGI("avoidAreaObj is finish");
+        TLOGI(WmsLogTag::WMS_UIEXT, "avoidAreaObj is finish");
         return avoidAreaObj;
     } else {
-        WLOGFE("avoidAreaObj is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "avoidAreaObj is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
 }
@@ -697,33 +696,33 @@ napi_value JsExtensionWindow::OnRegisterExtensionWindowCallback(napi_env env, na
 {
     sptr<Window> windowImpl = extensionWindow_->GetWindow();
     if (windowImpl == nullptr) {
-        WLOGFE("WindowImpl is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "WindowImpl is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     size_t argc = 4;
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (argc < 2) { // 2: params num
-        WLOGFE("Argc is invalid: %{public}zu", argc);
+        TLOGE(WmsLogTag::WMS_UIEXT, "Argc is invalid: %{public}zu", argc);
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
     std::string cbType;
     if (!ConvertFromJsValue(env, argv[0], cbType)) {
-        WLOGFE("Failed to convert parameter to callbackType");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert parameter to callbackType");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
     napi_value value = argv[1];
     if (!NapiIsCallable(env, value)) {
-        WLOGFE("Callback(info->argv[1]) is not callable");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Callback(info->argv[1]) is not callable");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
     WmErrorCode ret = extensionRegisterManager_->RegisterListener(windowImpl, cbType, CaseType::CASE_WINDOW,
         env, value);
     if (ret != WmErrorCode::WM_OK) {
-        WLOGFE("Callback(info->argv[1]) is not callable");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Callback(info->argv[1]) is not callable");
         return NapiThrowError(env, ret);
     }
-    WLOGI("Register end, window [%{public}u, %{public}s], type = %{public}s",
+    TLOGI(WmsLogTag::WMS_UIEXT, "Register end, window [%{public}u, %{public}s], type = %{public}s",
           windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), cbType.c_str());
     return NapiGetUndefined(env);
 }
@@ -732,19 +731,19 @@ napi_value JsExtensionWindow::OnUnRegisterExtensionWindowCallback(napi_env env,
 {
     sptr<Window> windowImpl = extensionWindow_->GetWindow();
     if (windowImpl == nullptr) {
-        WLOGFE("windowImpl is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "windowImpl is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     size_t argc = 4;
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (argc < 1) {
-        WLOGFE("Argc is invalid: %{public}zu", argc);
+        TLOGE(WmsLogTag::WMS_UIEXT, "Argc is invalid: %{public}zu", argc);
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
     std::string cbType;
     if (!ConvertFromJsValue(env, argv[0], cbType)) {
-        WLOGFE("Failed to convert parameter to callbackType");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert parameter to callbackType");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
 
@@ -765,7 +764,7 @@ napi_value JsExtensionWindow::OnUnRegisterExtensionWindowCallback(napi_env env,
     if (ret != WmErrorCode::WM_OK) {
         return NapiThrowError(env, ret);
     }
-    WLOGI("UnRegister end, window [%{public}u, %{public}s], type = %{public}s",
+    TLOGI(WmsLogTag::WMS_UIEXT, "UnRegister end, window [%{public}u, %{public}s], type = %{public}s",
           windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), cbType.c_str());
     return NapiGetUndefined(env);
 }
@@ -773,24 +772,24 @@ napi_value JsExtensionWindow::OnUnRegisterExtensionWindowCallback(napi_env env,
 napi_value JsExtensionWindow::OnHideNonSecureWindows(napi_env env, napi_callback_info info)
 {
     if (extensionWindow_ == nullptr) {
-        WLOGFE("extensionWindow_ is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "extensionWindow_ is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     sptr<Window> windowImpl = extensionWindow_->GetWindow();
     if (windowImpl == nullptr) {
-        WLOGFE("windowImpl is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "windowImpl is nullptr");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_STATE_ABNORMALLY);
     }
     size_t argc = 4;
     napi_value argv[4] = {nullptr};
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (argc < 1) {
-        WLOGFE("Argc is invalid: %{public}zu", argc);
+        TLOGE(WmsLogTag::WMS_UIEXT, "Argc is invalid: %{public}zu", argc);
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
     bool shouldHide = false;
     if (!ConvertFromJsValue(env, argv[0], shouldHide)) {
-        WLOGFE("Failed to convert parameter to bool");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert parameter to bool");
         return NapiThrowError(env, WmErrorCode::WM_ERROR_INVALID_PARAM);
     }
 
@@ -799,7 +798,7 @@ napi_value JsExtensionWindow::OnHideNonSecureWindows(napi_env env, napi_callback
     if (ret != WmErrorCode::WM_OK) {
         return NapiThrowError(env, ret);
     }
-    WLOGI("OnHideNonSecureWindows end, window [%{public}u, %{public}s], shouldHide:%{public}u",
+    TLOGI(WmsLogTag::WMS_UIEXT, "OnHideNonSecureWindows end, window [%{public}u, %{public}s], shouldHide:%{public}u",
           windowImpl->GetWindowId(), windowImpl->GetWindowName().c_str(), shouldHide);
     return NapiGetUndefined(env);
 }
@@ -840,14 +839,14 @@ napi_value JsExtensionWindow::OnSetWaterMarkFlag(napi_env env, napi_callback_inf
 
 napi_value JsExtensionWindow::GetProperties(napi_env env, napi_callback_info info)
 {
-    WLOGI("GetProperties is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "GetProperties is called");
     napi_value jsThis;
     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsThis, nullptr));
 
     JsExtensionWindow* jsExtensionWindow = nullptr;
     NAPI_CALL(env, napi_unwrap(env, jsThis, reinterpret_cast<void**>(&jsExtensionWindow)));
     if (!jsExtensionWindow || !jsExtensionWindow->extensionWindow_) {
-        WLOGFE("window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "window is nullptr");
         return nullptr;
     }
     sptr<Rosen::Window> window = jsExtensionWindow->extensionWindow_->GetWindow();
@@ -861,7 +860,7 @@ napi_value JsExtensionWindow::OnCreateSubWindowWithOptions(napi_env env, napi_ca
     napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     std::string windowName;
     if (!ConvertFromJsValue(env, argv[0], windowName)) {
-        WLOGFE("[NAPI]Failed to convert parameter to windowName");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Failed to convert parameter to windowName");
         napi_throw(env, CreateJsError(env, static_cast<int32_t>(WmErrorCode::WM_ERROR_INVALID_PARAM)));
         return NapiGetUndefined(env);
     }
@@ -891,7 +890,7 @@ napi_value JsExtensionWindow::OnCreateSubWindowWithOptions(napi_env env, napi_ca
                 return;
             }
             task.Resolve(env, CreateJsWindowObject(env, window));
-            WLOGI("[NAPI]Create sub window %{public}s end", windowName.c_str());
+            TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Create sub window %{public}s end", windowName.c_str());
         };
     napi_value callback = (argv[2] != nullptr && GetType(env, argv[2]) == napi_function) ? argv[2] : nullptr;
     napi_value result = nullptr;
diff --git a/interfaces/kits/napi/extension_window/js_extension_window_listener.cpp b/interfaces/kits/napi/extension_window/js_extension_window_listener.cpp
index 272ddd61ce87827a57cf2d1c129058e9cdc39e90..fc7dfd3390b4c704409959bd7b8e8c03863a5328 100644
--- a/interfaces/kits/napi/extension_window/js_extension_window_listener.cpp
+++ b/interfaces/kits/napi/extension_window/js_extension_window_listener.cpp
@@ -27,7 +27,6 @@ namespace OHOS {
 namespace Rosen {
 using namespace AbilityRuntime;
 namespace {
-constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsExtensionWindowListener"};
 const std::string WINDOW_SIZE_CHANGE_CB = "windowSizeChange";
 const std::string SYSTEM_AVOID_AREA_CHANGE_CB = "systemAvoidAreaChange";
 const std::string AVOID_AREA_CHANGE_CB = "avoidAreaChange";
@@ -37,7 +36,7 @@ const std::string KEYBOARD_HEIGHT_CHANGE_CB = "keyboardHeightChange";
 
 JsExtensionWindowListener::~JsExtensionWindowListener()
 {
-    WLOGI("[NAPI]~JsExtensionWindowListener");
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]~JsExtensionWindowListener");
 }
 
 void JsExtensionWindowListener::SetMainEventHandler()
@@ -51,14 +50,14 @@ void JsExtensionWindowListener::SetMainEventHandler()
 
 void JsExtensionWindowListener::CallJsMethod(const char* methodName, napi_value const * argv, size_t argc)
 {
-    WLOGI("[NAPI]CallJsMethod methodName = %{public}s", methodName);
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]CallJsMethod methodName = %{public}s", methodName);
     if (env_ == nullptr || jsCallBack_ == nullptr) {
-        WLOGFE("[NAPI]env_ nullptr or jsCallBack_ is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]env_ nullptr or jsCallBack_ is nullptr");
         return;
     }
     napi_value method = jsCallBack_->GetNapiValue();
     if (method == nullptr) {
-        WLOGFE("[NAPI]Failed to get method callback from object");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Failed to get method callback from object");
         return;
     }
     napi_value result = nullptr;
@@ -69,9 +68,10 @@ void JsExtensionWindowListener::CallJsMethod(const char* methodName, napi_value
 void JsExtensionWindowListener::OnSizeChange(Rect rect, WindowSizeChangeReason reason,
     const std::shared_ptr<RSTransaction>& rsTransaction)
 {
-    WLOGI("[NAPI]OnSizeChange, [%{public}u, %{public}u], reason=%{public}u", rect.width_, rect.height_, reason);
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]OnSizeChange, [%{public}u, %{public}u], reason=%{public}u",
+        rect.width_, rect.height_, reason);
     if (currentWidth_ == rect.width_ && currentHeight_ == rect.height_ && reason != WindowSizeChangeReason::DRAG_END) {
-        WLOGFD("[NAPI]no need to change size");
+        TLOGD(WmsLogTag::WMS_UIEXT, "[NAPI]no need to change size");
         return;
     }
     // js callback should run in js thread
@@ -79,7 +79,7 @@ void JsExtensionWindowListener::OnSizeChange(Rect rect, WindowSizeChangeReason r
         HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsExtensionWindowListener::OnSizeChange");
         auto thisListener = self.promote();
         if (thisListener == nullptr || eng == nullptr) {
-            WLOGFE("[NAPI]this listener or eng is nullptr");
+            TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]this listener or eng is nullptr");
             return;
         }
         napi_handle_scope scope = nullptr;
@@ -87,7 +87,7 @@ void JsExtensionWindowListener::OnSizeChange(Rect rect, WindowSizeChangeReason r
         napi_value objValue = nullptr;
         napi_create_object(eng, &objValue);
         if (objValue == nullptr) {
-            WLOGFE("Failed to convert rect to jsObject");
+            TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert rect to jsObject");
             return;
         }
         napi_set_named_property(eng, objValue, "width", CreateJsValue(eng, rect.width_));
@@ -100,7 +100,7 @@ void JsExtensionWindowListener::OnSizeChange(Rect rect, WindowSizeChangeReason r
         jsCallback();
     } else {
         if (!eventHandler_) {
-            WLOGFE("get main event handler failed!");
+            TLOGE(WmsLogTag::WMS_UIEXT, "get main event handler failed!");
             return;
         }
         eventHandler_->PostTask(jsCallback, "wms:JsExtensionWindowListener::OnSizeChange", 0,
@@ -112,18 +112,18 @@ void JsExtensionWindowListener::OnSizeChange(Rect rect, WindowSizeChangeReason r
 
 void JsExtensionWindowListener::OnModeChange(WindowMode mode, bool hasDeco)
 {
-    WLOGI("[NAPI]OnModeChange %{public}u", mode);
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]OnModeChange %{public}u", mode);
 }
 
 void JsExtensionWindowListener::OnAvoidAreaChanged(const AvoidArea avoidArea, AvoidAreaType type)
 {
-    WLOGFI("[NAPI]OnAvoidAreaChanged");
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]OnAvoidAreaChanged");
     // js callback should run in js thread
     std::unique_ptr<NapiAsyncTask::CompleteCallback> complete = std::make_unique<NapiAsyncTask::CompleteCallback> (
         [self = weakRef_, avoidArea, type, eng = env_] (napi_env env, NapiAsyncTask &task, int32_t status) {
             auto thisListener = self.promote();
             if (thisListener == nullptr || eng == nullptr) {
-                WLOGFE("[NAPI]this listener or eng is nullptr");
+                TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]this listener or eng is nullptr");
                 return;
             }
             napi_value avoidAreaValue = ConvertAvoidAreaToJsValue(env, avoidArea, type);
@@ -137,7 +137,7 @@ void JsExtensionWindowListener::OnAvoidAreaChanged(const AvoidArea avoidArea, Av
                 napi_value objValue = nullptr;
                 napi_create_object(env, &objValue);
                 if (objValue == nullptr) {
-                    WLOGFE("Failed to get object");
+                    TLOGE(WmsLogTag::WMS_UIEXT, "Failed to get object");
                     return;
                 }
                 napi_set_named_property(env, objValue, "type",
@@ -158,15 +158,16 @@ void JsExtensionWindowListener::OnAvoidAreaChanged(const AvoidArea avoidArea, Av
 void JsExtensionWindowListener::OnSizeChange(const sptr<OccupiedAreaChangeInfo>& info,
                                              const std::shared_ptr<RSTransaction>& rsTransaction)
 {
-    WLOGI("[NAPI]OccupiedAreaChangeInfo, type: %{public}d, input rect:[%{public}d, %{public}d, %{public}d, %{public}d]",
-          static_cast<uint32_t>(info->type_), info->rect_.posX_, info->rect_.posY_, info->rect_.width_,
-          info->rect_.height_);
+    TLOGI(WmsLogTag::WMS_UIEXT,
+        "[NAPI]OccupiedAreaChangeInfo, type: %{public}d, input rect:[%{public}d, %{public}d, %{public}d, %{public}d]",
+        static_cast<uint32_t>(info->type_), info->rect_.posX_, info->rect_.posY_, info->rect_.width_,
+        info->rect_.height_);
     // js callback should run in js thread
     std::unique_ptr<NapiAsyncTask::CompleteCallback> complete = std::make_unique<NapiAsyncTask::CompleteCallback> (
         [self = weakRef_, info, eng = env_] (napi_env env, NapiAsyncTask& task, int32_t status) {
             auto thisListener = self.promote();
             if (thisListener == nullptr || eng == nullptr) {
-                WLOGFE("[NAPI]this listener or eng is nullptr");
+                TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]this listener or eng is nullptr");
                 return;
             }
             napi_value argv[] = {CreateJsValue(eng, info->rect_.height_)};
@@ -183,12 +184,12 @@ void JsExtensionWindowListener::OnSizeChange(const sptr<OccupiedAreaChangeInfo>&
 static void LifeCycleCallBack(LifeCycleEventType eventType, wptr<JsExtensionWindowListener> weakRef,
     napi_env env, std::shared_ptr<AppExecFwk::EventHandler> eventHandler)
 {
-    WLOGI("LifeCycleCallBack, envent type: %{public}u", eventType);
+    TLOGI(WmsLogTag::WMS_UIEXT, "LifeCycleCallBack, envent type: %{public}u", eventType);
     auto task = [self = weakRef, eventType, eng = env] () {
         HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "JsExtensionWindowListener::LifeCycleCallBack");
         auto thisListener = self.promote();
         if (thisListener == nullptr || eng == nullptr) {
-            WLOGFE("this listener or eng is nullptr");
+            TLOGE(WmsLogTag::WMS_UIEXT, "this listener or eng is nullptr");
             return;
         }
         napi_handle_scope scope = nullptr;
@@ -198,7 +199,7 @@ static void LifeCycleCallBack(LifeCycleEventType eventType, wptr<JsExtensionWind
         napi_close_handle_scope(eng, scope);
     };
     if (!eventHandler) {
-        WLOGFE("get main event handler failed!");
+        TLOGE(WmsLogTag::WMS_UIEXT, "get main event handler failed!");
         return;
     }
     eventHandler->PostTask(task, "wms:JsExtensionWindowListener::LifeCycleCallBack", 0,
@@ -211,7 +212,7 @@ void JsExtensionWindowListener::AfterForeground()
         LifeCycleCallBack(LifeCycleEventType::FOREGROUND, weakRef_, env_, eventHandler_);
         state_ = WindowState::STATE_SHOWN;
     } else {
-        WLOGFD("window is already shown");
+        TLOGD(WmsLogTag::WMS_UIEXT, "window is already shown");
     }
 }
 
@@ -221,7 +222,7 @@ void JsExtensionWindowListener::AfterBackground()
         LifeCycleCallBack(LifeCycleEventType::BACKGROUND, weakRef_, env_, eventHandler_);
         state_ = WindowState::STATE_HIDDEN;
     } else {
-        WLOGFD("window is already hide");
+        TLOGD(WmsLogTag::WMS_UIEXT, "window is already hide");
     }
 }
 
diff --git a/interfaces/kits/napi/extension_window/js_extension_window_register_manager.cpp b/interfaces/kits/napi/extension_window/js_extension_window_register_manager.cpp
index 06390de38d368c4ee002e8510f6f9188aef79c48..5309ed38f6b8078ffd2296d0de7c4c579538f057 100644
--- a/interfaces/kits/napi/extension_window/js_extension_window_register_manager.cpp
+++ b/interfaces/kits/napi/extension_window/js_extension_window_register_manager.cpp
@@ -20,7 +20,6 @@
 namespace OHOS {
 namespace Rosen {
 namespace {
-constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsExtensionWindowRegisterManager"};
 const std::string WINDOW_SIZE_CHANGE_CB = "windowSizeChange";
 const std::string AVOID_AREA_CHANGE_CB = "avoidAreaChange";
 const std::string WINDOW_STAGE_EVENT_CB = "windowStageEvent";
@@ -49,7 +48,7 @@ WmErrorCode JsExtensionWindowRegisterManager::ProcessWindowChangeRegister(sptr<J
     sptr<Window> window, bool isRegister)
 {
     if (window == nullptr) {
-        WLOGFE("[NAPI]Window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Window is nullptr");
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     sptr<IWindowChangeListener> thisListener(listener);
@@ -66,7 +65,7 @@ WmErrorCode JsExtensionWindowRegisterManager::ProcessAvoidAreaChangeRegister(spt
     sptr<Window> window, bool isRegister)
 {
     if (window == nullptr) {
-        WLOGFE("[NAPI]Window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Window is nullptr");
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     sptr<IAvoidAreaChangedListener> thisListener(listener);
@@ -83,7 +82,7 @@ WmErrorCode JsExtensionWindowRegisterManager::ProcessLifeCycleEventRegister(sptr
     sptr<Window> window, bool isRegister)
 {
     if (window == nullptr) {
-        WLOGFE("Window is nullptr");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Window is nullptr");
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     sptr<IWindowLifeCycle> thisListener(listener);
@@ -99,7 +98,7 @@ WmErrorCode JsExtensionWindowRegisterManager::ProcessLifeCycleEventRegister(sptr
 bool JsExtensionWindowRegisterManager::IsCallbackRegistered(napi_env env, std::string type, napi_value jsListenerObject)
 {
     if (jsCbMap_.empty() || jsCbMap_.find(type) == jsCbMap_.end()) {
-        WLOGI("[NAPI]Method %{public}s has not been registered", type.c_str());
+        TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Method %{public}s has not been registered", type.c_str());
         return false;
     }
 
@@ -107,7 +106,7 @@ bool JsExtensionWindowRegisterManager::IsCallbackRegistered(napi_env env, std::s
         bool isEquals = false;
         napi_strict_equals(env, jsListenerObject, iter->first->GetNapiValue(), &isEquals);
         if (isEquals) {
-            WLOGFE("[NAPI]Method %{public}s has already been registered", type.c_str());
+            TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Method %{public}s has already been registered", type.c_str());
             return true;
         }
     }
@@ -122,7 +121,7 @@ WmErrorCode JsExtensionWindowRegisterManager::RegisterListener(sptr<Window> wind
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     if (listenerProcess_[caseType].count(type) == 0) {
-        WLOGFE("[NAPI]Type %{public}s is not supported", type.c_str());
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Type %{public}s is not supported", type.c_str());
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     napi_ref result = nullptr;
@@ -131,17 +130,17 @@ WmErrorCode JsExtensionWindowRegisterManager::RegisterListener(sptr<Window> wind
     sptr<JsExtensionWindowListener> extensionWindowListener =
         new(std::nothrow) JsExtensionWindowListener(env, callbackRef);
     if (extensionWindowListener == nullptr) {
-        WLOGFE("[NAPI]New JsExtensionWindowListener failed");
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]New JsExtensionWindowListener failed");
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     extensionWindowListener->SetMainEventHandler();
     WmErrorCode ret = (this->*listenerProcess_[caseType][type])(extensionWindowListener, window, true);
     if (ret != WmErrorCode::WM_OK) {
-        WLOGFE("[NAPI]Register type %{public}s failed", type.c_str());
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Register type %{public}s failed", type.c_str());
         return ret;
     }
     jsCbMap_[type][callbackRef] = extensionWindowListener;
-    WLOGI("[NAPI]Register type %{public}s success! callback map size: %{public}zu", type.c_str(),
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Register type %{public}s success! callback map size: %{public}zu", type.c_str(),
           jsCbMap_[type].size());
     return WmErrorCode::WM_OK;
 }
@@ -151,18 +150,18 @@ WmErrorCode JsExtensionWindowRegisterManager::UnregisterListener(sptr<Window> wi
 {
     std::lock_guard<std::mutex> lock(mtx_);
     if (jsCbMap_.empty() || jsCbMap_.find(type) == jsCbMap_.end()) {
-        WLOGFE("[NAPI]Type %{public}s was not registered", type.c_str());
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Type %{public}s was not registered", type.c_str());
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     if (listenerProcess_[caseType].count(type) == 0) {
-        WLOGFE("[NAPI]Type %{public}s is not supported", type.c_str());
+        TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Type %{public}s is not supported", type.c_str());
         return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
     }
     if (value == nullptr) {
         for (auto it = jsCbMap_[type].begin(); it != jsCbMap_[type].end();) {
             WmErrorCode ret = (this->*listenerProcess_[caseType][type])(it->second, window, false);
             if (ret != WmErrorCode::WM_OK) {
-                WLOGFE("[NAPI]Unregister type %{public}s failed, no value", type.c_str());
+                TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Unregister type %{public}s failed, no value", type.c_str());
                 return ret;
             }
             jsCbMap_[type].erase(it++);
@@ -178,18 +177,19 @@ WmErrorCode JsExtensionWindowRegisterManager::UnregisterListener(sptr<Window> wi
             findFlag = true;
             WmErrorCode ret = (this->*listenerProcess_[caseType][type])(it->second, window, false);
             if (ret != WmErrorCode::WM_OK) {
-                WLOGFE("[NAPI]Unregister type %{public}s failed", type.c_str());
+                TLOGE(WmsLogTag::WMS_UIEXT, "[NAPI]Unregister type %{public}s failed", type.c_str());
                 return ret;
             }
             jsCbMap_[type].erase(it);
             break;
         }
         if (!findFlag) {
-            WLOGFE("[NAPI]Unregister type %{public}s failed because not found callback!", type.c_str());
+            TLOGE(WmsLogTag::WMS_UIEXT,
+                "[NAPI]Unregister type %{public}s failed because not found callback!", type.c_str());
             return WmErrorCode::WM_ERROR_STATE_ABNORMALLY;
         }
     }
-    WLOGI("[NAPI]Unregister type %{public}s success! callback map size: %{public}zu",
+    TLOGI(WmsLogTag::WMS_UIEXT, "[NAPI]Unregister type %{public}s success! callback map size: %{public}zu",
         type.c_str(), jsCbMap_[type].size());
     // erase type when there is no callback in one type
     if (jsCbMap_[type].empty()) {
diff --git a/interfaces/kits/napi/extension_window/js_extension_window_utils.cpp b/interfaces/kits/napi/extension_window/js_extension_window_utils.cpp
index d9f1cc191bad7d0c0043ac0f135d2788ea5488e7..e084525005f0c2d9bcbecb2abbc76c5c92ec2e37 100644
--- a/interfaces/kits/napi/extension_window/js_extension_window_utils.cpp
+++ b/interfaces/kits/napi/extension_window/js_extension_window_utils.cpp
@@ -22,16 +22,13 @@
 namespace OHOS {
 namespace Rosen {
 using namespace  AbilityRuntime;
-namespace {
-constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsExtensionWindowUtils"};
-}
 
 napi_value GetRectAndConvertToJsValue(napi_env env, const Rect& rect)
 {
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
     if (objValue == nullptr) {
-        WLOGFE("Failed to convert rect to jsObject");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert rect to jsObject");
         return nullptr;
     }
     napi_set_named_property(env, objValue, "left", CreateJsValue(env, rect.posX_));
@@ -46,7 +43,7 @@ napi_value ConvertAvoidAreaToJsValue(napi_env env, const AvoidArea& avoidArea, A
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
     if (objValue == nullptr) {
-        WLOGFE("Failed to convert avoidArea to jsObject");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert avoidArea to jsObject");
         return nullptr;
     }
     napi_set_named_property(env, objValue, "visible",
@@ -60,18 +57,18 @@ napi_value ConvertAvoidAreaToJsValue(napi_env env, const AvoidArea& avoidArea, A
 
 napi_value CreateJsExtensionWindowPropertiesObject(napi_env env, sptr<Window>& window)
 {
-    WLOGI("CreateJsExtensionWindowPropertiesObject is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "CreateJsExtensionWindowPropertiesObject is called");
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
     if (objValue == nullptr) {
-        WLOGFE("Failed to convert windowProperties to jsObject");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert windowProperties to jsObject");
         return nullptr;
     }
 
     Rect windowRect = window->GetRect();
     napi_value windowRectObj = GetRectAndConvertToJsValue(env, windowRect);
     if (windowRectObj == nullptr) {
-        WLOGFE("GetWindowRect Failed");
+        TLOGE(WmsLogTag::WMS_UIEXT, "GetWindowRect Failed");
     }
     napi_set_named_property(env, objValue, "uiExtensionHostWindowProxyRect", windowRectObj);
     return objValue;
@@ -79,18 +76,18 @@ napi_value CreateJsExtensionWindowPropertiesObject(napi_env env, sptr<Window>& w
 
 napi_value CreateJsExtensionWindowProperties(napi_env env, sptr<Window>& window)
 {
-    WLOGI("CreateJsWindowPropertiesObject is called");
+    TLOGI(WmsLogTag::WMS_UIEXT, "CreateJsWindowPropertiesObject is called");
     napi_value objValue = nullptr;
     napi_create_object(env, &objValue);
     if (objValue == nullptr) {
-        WLOGFE("Failed to convert windowProperties to jsObject");
+        TLOGE(WmsLogTag::WMS_UIEXT, "Failed to convert windowProperties to jsObject");
         return nullptr;
     }
 
     Rect windowRect = window->GetRect();
     napi_value windowRectObj = GetRectAndConvertToJsValue(env, windowRect);
     if (windowRectObj == nullptr) {
-        WLOGFE("GetWindowRect failed!");
+        TLOGE(WmsLogTag::WMS_UIEXT, "GetWindowRect failed!");
     }
     napi_set_named_property(env, objValue, "windowRect", windowRectObj);
     
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index 0e1371f5d525d60064847275fd9899436f690ed7..2fceb6bbee9c08ea4a5dabda20e68d74bf294c06 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -6469,9 +6469,16 @@ void DisplayChangeListener::OnScreenshot(DisplayId displayId)
 void SceneSessionManager::OnScreenshot(DisplayId displayId)
 {
     auto task = [this, displayId]() {
-        auto sceneSession = GetSceneSession(focusedSessionId_);
-        if (sceneSession) {
-            sceneSession->NotifyScreenshot();
+        std::shared_lock<std::shared_mutex> lock(sceneSessionMapMutex_);
+        for (const auto& iter : sceneSessionMap_) {
+            auto sceneSession = iter.second;
+            if (sceneSession == nullptr) {
+                continue;
+            }
+            auto state = sceneSession->GetSessionState();
+            if (state == SessionState::STATE_FOREGROUND || state == SessionState::STATE_ACTIVE) {
+                sceneSession->NotifyScreenshot();
+            }
         }
     };
     taskScheduler_->PostAsyncTask(task, "OnScreenshot:PID:" + std::to_string(displayId));
diff --git a/wmserver/include/window_root.h b/wmserver/include/window_root.h
index 525a67c466f467815f7c07ee2b9fb0d38f721d9f..bb611f7b0f2874a7c9a7b2663ceb3d8373d62c81 100644
--- a/wmserver/include/window_root.h
+++ b/wmserver/include/window_root.h
@@ -44,6 +44,7 @@ public:
     sptr<WindowNode> GetWindowNode(uint32_t windowId) const;
     sptr<WindowNode> GetWindowNodeByMissionId(uint32_t missionId) const;
     void GetBackgroundNodesByScreenId(ScreenId screenGroupId, std::vector<sptr<WindowNode>>& windowNodes);
+    void GetForegroundNodes(std::vector<sptr<WindowNode>>& windowNodes);
 
     sptr<WindowNode> FindWallpaperWindow();
     WMError SaveWindow(const sptr<WindowNode>& node);
diff --git a/wmserver/src/window_controller.cpp b/wmserver/src/window_controller.cpp
index ab075b02f06494aa4794c1c9cb7c41edb7971317..c0ca47588fb772822dfccd1c09df5a017df1bd19 100644
--- a/wmserver/src/window_controller.cpp
+++ b/wmserver/src/window_controller.cpp
@@ -1817,17 +1817,14 @@ void WindowController::MinimizeWindowsByLauncher(std::vector<uint32_t>& windowId
 
 void WindowController::OnScreenshot(DisplayId displayId)
 {
-    sptr<WindowNode> windowNode;
-    WMError res = GetFocusWindowNode(displayId, windowNode);
-    if (res != WMError::WM_OK) {
-        return;
-    }
-    auto windowToken = windowNode->GetWindowToken();
-    if (windowToken == nullptr) {
-        WLOGFE("notify screenshot failed: window token is null.");
-        return;
+    std::vector<sptr<WindowNode>> windowNodes;
+    windowRoot_->GetForegroundNodes(windowNodes);
+    for (auto& windowNode : windowNodes) {
+        auto windowToken = windowNode->GetWindowToken();
+        if (windowToken != nullptr) {
+            windowToken->NotifyScreenshot();
+        }
     }
-    windowToken->NotifyScreenshot();
 }
 
 void WindowController::SetAnchorOffset(int32_t deltaX, int32_t deltaY)
diff --git a/wmserver/src/window_root.cpp b/wmserver/src/window_root.cpp
index f020945b069bf95af7c7317958511ffe603840ed..c7cc9a6f935a4c1e90ea397555274d3835d7ba2b 100644
--- a/wmserver/src/window_root.cpp
+++ b/wmserver/src/window_root.cpp
@@ -194,6 +194,18 @@ void WindowRoot::GetBackgroundNodesByScreenId(ScreenId screenGroupId, std::vecto
     }
 }
 
+void WindowRoot::GetForegroundNodes(std::vector<sptr<WindowNode>>& windowNodes)
+{
+    for (const auto& it : windowNodeMap_) {
+        if (it.second == nullptr) {
+            continue;
+        }
+        if (it.second->currentVisibility_) {
+            windowNodes.push_back(it.second);
+        }
+    }
+}
+
 sptr<WindowNode> WindowRoot::FindWindowNodeWithToken(const sptr<IRemoteObject>& token) const
 {
     if (token == nullptr) {