diff --git a/dm/src/display_manager.cpp b/dm/src/display_manager.cpp
index 8e5284f4fd5d475792c1959c653f2f48ecad46fa..b2777914faa1a2b08189a3e80332e1348be570af 100644
--- a/dm/src/display_manager.cpp
+++ b/dm/src/display_manager.cpp
@@ -453,7 +453,7 @@ bool DisplayManager::Impl::RegisterDisplayPowerEventListener(sptr<IDisplayPowerE
     } else {
         powerEventListeners_.insert(listener);
     }
-    WLOGFI("RegisterDisplayPowerEventListener end");
+    WLOGFD("RegisterDisplayPowerEventListener end");
     return ret;
 }
 
@@ -482,7 +482,7 @@ bool DisplayManager::Impl::UnregisterDisplayPowerEventListener(sptr<IDisplayPowe
             DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER);
         powerEventListenerAgent_ = nullptr;
     }
-    WLOGFI("UnregisterDisplayPowerEventListener end");
+    WLOGFD("UnregisterDisplayPowerEventListener end");
     return ret;
 }
 
@@ -497,7 +497,7 @@ bool DisplayManager::UnregisterDisplayPowerEventListener(sptr<IDisplayPowerEvent
 
 void DisplayManager::Impl::NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status)
 {
-    WLOGFI("NotifyDisplayPowerEvent event:%{public}u, status:%{public}u, size:%{public}zu", event, status,
+    WLOGFD("NotifyDisplayPowerEvent event:%{public}u, status:%{public}u, size:%{public}zu", event, status,
         powerEventListeners_.size());
     std::set<sptr<IDisplayPowerEventListener>> powerEventListeners;
     {
@@ -511,7 +511,7 @@ void DisplayManager::Impl::NotifyDisplayPowerEvent(DisplayPowerEvent event, Even
 
 void DisplayManager::Impl::NotifyDisplayStateChanged(DisplayId id, DisplayState state)
 {
-    WLOGFI("state:%{public}u", state);
+    WLOGFD("state:%{public}u", state);
     DisplayStateCallback displayStateCallback;
     {
         std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -533,7 +533,7 @@ void DisplayManager::Impl::NotifyDisplayCreate(sptr<DisplayInfo> info)
 
 void DisplayManager::Impl::NotifyDisplayDestroy(DisplayId displayId)
 {
-    WLOGFI("displayId:%{public}" PRIu64".", displayId);
+    WLOGFD("displayId:%{public}" PRIu64".", displayId);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     displayMap_.erase(displayId);
 }
@@ -551,14 +551,14 @@ bool DisplayManager::Impl::UpdateDisplayInfoLocked(sptr<DisplayInfo> displayInfo
         return false;
     }
     DisplayId displayId = displayInfo->GetDisplayId();
-    WLOGFI("displayId:%{public}" PRIu64".", displayId);
+    WLOGFD("displayId:%{public}" PRIu64".", displayId);
     if (displayId == DISPLAY_ID_INVALID) {
         WLOGFE("displayId is invalid.");
         return false;
     }
     auto iter = displayMap_.find(displayId);
     if (iter != displayMap_.end() && iter->second != nullptr) {
-        WLOGFI("get screen in screen map");
+        WLOGFD("get screen in screen map");
         iter->second->UpdateDisplayInfo(displayInfo);
         return true;
     }
@@ -569,32 +569,32 @@ bool DisplayManager::Impl::UpdateDisplayInfoLocked(sptr<DisplayInfo> displayInfo
 
 bool DisplayManager::WakeUpBegin(PowerStateChangeReason reason)
 {
-    WLOGFI("WakeUpBegin start, reason:%{public}u", reason);
+    WLOGFD("WakeUpBegin start, reason:%{public}u", reason);
     return SingletonContainer::Get<DisplayManagerAdapter>().WakeUpBegin(reason);
 }
 
 bool DisplayManager::WakeUpEnd()
 {
-    WLOGFI("WakeUpEnd start");
+    WLOGFD("WakeUpEnd start");
     return SingletonContainer::Get<DisplayManagerAdapter>().WakeUpEnd();
 }
 
 bool DisplayManager::SuspendBegin(PowerStateChangeReason reason)
 {
     // dms->wms notify other windows to hide
-    WLOGFI("SuspendBegin start, reason:%{public}u", reason);
+    WLOGFD("SuspendBegin start, reason:%{public}u", reason);
     return SingletonContainer::Get<DisplayManagerAdapter>().SuspendBegin(reason);
 }
 
 bool DisplayManager::SuspendEnd()
 {
-    WLOGFI("SuspendEnd start");
+    WLOGFD("SuspendEnd start");
     return SingletonContainer::Get<DisplayManagerAdapter>().SuspendEnd();
 }
 
 bool DisplayManager::Impl::SetDisplayState(DisplayState state, DisplayStateCallback callback)
 {
-    WLOGFI("state:%{public}u", state);
+    WLOGFD("state:%{public}u", state);
     bool ret = true;
     {
         std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -630,7 +630,7 @@ DisplayState DisplayManager::GetDisplayState(DisplayId displayId)
 
 bool DisplayManager::SetScreenBrightness(uint64_t screenId, uint32_t level)
 {
-    WLOGFI("screenId:%{public}" PRIu64", level:%{public}u,", screenId, level);
+    WLOGFD("screenId:%{public}" PRIu64", level:%{public}u,", screenId, level);
     RSInterfaces::GetInstance().SetScreenBacklight(screenId, level);
     return true;
 }
@@ -645,7 +645,7 @@ uint32_t DisplayManager::GetScreenBrightness(uint64_t screenId) const
 void DisplayManager::NotifyDisplayEvent(DisplayEvent event)
 {
     // Unlock event dms->wms restore other hidden windows
-    WLOGFI("DisplayEvent:%{public}u", event);
+    WLOGFD("DisplayEvent:%{public}u", event);
     SingletonContainer::Get<DisplayManagerAdapter>().NotifyDisplayEvent(event);
 }
 
diff --git a/wm/src/input_transfer_station.cpp b/wm/src/input_transfer_station.cpp
index c3e62a38dc62ad700d92f5515763d9a32a49259e..ff18b9e696fb8edadf00b6de74712a1a96c26c92 100644
--- a/wm/src/input_transfer_station.cpp
+++ b/wm/src/input_transfer_station.cpp
@@ -30,7 +30,7 @@ void InputEventListener::OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) c
         return;
     }
     uint32_t windowId = static_cast<uint32_t>(keyEvent->GetAgentWindowId());
-    WLOGFI("Receive keyEvent, windowId: %{public}u", windowId);
+    WLOGFD("Receive keyEvent, windowId: %{public}u", windowId);
     auto channel = InputTransferStation::GetInstance().GetInputChannel(windowId);
     if (channel == nullptr) {
         WLOGFE("WindowInputChannel is nullptr");
@@ -45,7 +45,7 @@ void InputEventListener::OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent)
         WLOGFE("AxisEvent is nullptr");
         return;
     }
-    WLOGFI("Receive axisEvent, windowId: %{public}d", axisEvent->GetAgentWindowId());
+    WLOGFD("Receive axisEvent, windowId: %{public}d", axisEvent->GetAgentWindowId());
     axisEvent->MarkProcessed();
 }
 
@@ -56,7 +56,7 @@ void InputEventListener::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointer
         return;
     }
     uint32_t windowId = static_cast<uint32_t>(pointerEvent->GetAgentWindowId());
-    WLOGFI("Receive pointerEvent, windowId: %{public}u", windowId);
+    WLOGFD("Receive pointerEvent, windowId: %{public}u", windowId);
     auto channel = InputTransferStation::GetInstance().GetInputChannel(windowId);
     if (channel == nullptr) {
         WLOGFE("WindowInputChannel is nullptr");
@@ -68,12 +68,12 @@ void InputEventListener::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointer
 void InputTransferStation::AddInputWindow(const sptr<Window>& window)
 {
     uint32_t windowId = window->GetWindowId();
-    WLOGFI("Add input window, windowId: %{public}u", windowId);
+    WLOGFD("Add input window, windowId: %{public}u", windowId);
     sptr<WindowInputChannel> inputChannel = new WindowInputChannel(window);
     std::lock_guard<std::mutex> lock(mtx_);
     windowInputChannels_.insert(std::make_pair(windowId, inputChannel));
     if (inputListener_ == nullptr) {
-        WLOGFI("Init input listener");
+        WLOGFD("Init input listener");
         std::shared_ptr<MMI::IInputEventConsumer> listener = std::make_shared<InputEventListener>(InputEventListener());
         MMI::InputManager::GetInstance()->SetWindowInputEventConsumer(listener);
         inputListener_ = listener;
@@ -82,7 +82,7 @@ void InputTransferStation::AddInputWindow(const sptr<Window>& window)
 
 void InputTransferStation::RemoveInputWindow(uint32_t windowId)
 {
-    WLOGFI("Remove input window, windowId: %{public}u", windowId);
+    WLOGFD("Remove input window, windowId: %{public}u", windowId);
     sptr<WindowInputChannel> inputChannel = nullptr;
     {
         std::lock_guard<std::mutex> lock(mtx_);
@@ -102,7 +102,7 @@ void InputTransferStation::RemoveInputWindow(uint32_t windowId)
 void InputTransferStation::SetInputListener(
     uint32_t windowId, const std::shared_ptr<MMI::IInputEventConsumer>& listener)
 {
-    WLOGFI("windowId: %{public}u", windowId);
+    WLOGFD("windowId: %{public}u", windowId);
     auto channel = GetInputChannel(windowId);
     if (channel == nullptr) {
         WLOGFE("WindowInputChannel is nullptr, windowId: %{public}u", windowId);
diff --git a/wm/src/window_impl.cpp b/wm/src/window_impl.cpp
index b6f1adf5ec11213d16ea3b9f2dd9a59fc8541920..8ee0619e610fc096f1fbf760d24d5613dc6d16b0 100755
--- a/wm/src/window_impl.cpp
+++ b/wm/src/window_impl.cpp
@@ -311,7 +311,7 @@ WMError WindowImpl::GetAvoidAreaByType(AvoidAreaType type, AvoidArea& avoidArea)
 
 WMError WindowImpl::SetWindowType(WindowType type)
 {
-    WLOGFI("window id: %{public}u, type:%{public}u.", property_->GetWindowId(), static_cast<uint32_t>(type));
+    WLOGFD("window id: %{public}u, type:%{public}u.", property_->GetWindowId(), static_cast<uint32_t>(type));
     if (!IsWindowValid()) {
         return WMError::WM_ERROR_INVALID_WINDOW;
     }
@@ -444,7 +444,7 @@ WMError WindowImpl::SetWindowFlags(uint32_t flags)
 
 void WindowImpl::OnNewWant(const AAFwk::Want& want)
 {
-    WLOGFI("[Client] Window [name:%{public}s, id:%{public}u] OnNewWant", name_.c_str(), property_->GetWindowId());
+    WLOGFD("[Client] Window [name:%{public}s, id:%{public}u] OnNewWant", name_.c_str(), property_->GetWindowId());
     if (uiContent_ != nullptr) {
         uiContent_->OnNewWant(want);
     }
@@ -453,7 +453,7 @@ void WindowImpl::OnNewWant(const AAFwk::Want& want)
 WMError WindowImpl::SetUIContent(const std::string& contentInfo,
     NativeEngine* engine, NativeValue* storage, bool isdistributed, AppExecFwk::Ability* ability)
 {
-    WLOGFI("SetUIContent contentInfo: %{public}s", contentInfo.c_str());
+    WLOGFD("SetUIContent contentInfo: %{public}s", contentInfo.c_str());
     std::unique_ptr<Ace::UIContent> uiContent;
     if (ability != nullptr) {
         uiContent = Ace::UIContent::Create(ability);
@@ -491,7 +491,7 @@ WMError WindowImpl::SetUIContent(const std::string& contentInfo,
         float virtualPixelRatio = display->GetVirtualPixelRatio();
         config.SetDensity(virtualPixelRatio);
         uiContent_->UpdateViewportConfig(config, WindowSizeChangeReason::UNDEFINED);
-        WLOGFI("notify uiContent window size change end");
+        WLOGFD("notify uiContent window size change end");
     }
     return WMError::WM_OK;
 }
@@ -503,7 +503,7 @@ Ace::UIContent* WindowImpl::GetUIContent() const
 
 std::string WindowImpl::GetContentInfo()
 {
-    WLOGFI("GetContentInfo");
+    WLOGFD("GetContentInfo");
     if (uiContent_ == nullptr) {
         WLOGFE("fail to GetContentInfo id: %{public}u", property_->GetWindowId());
         return "";
@@ -550,7 +550,7 @@ ColorSpace WindowImpl::GetColorSpace()
 
 std::shared_ptr<Media::PixelMap> WindowImpl::Snapshot()
 {
-    WLOGFI("WMS-Clinet Snapshot");
+    WLOGFD("WMS-Clinet Snapshot");
     std::shared_ptr<SurfaceCaptureFuture> callback = std::make_shared<SurfaceCaptureFuture>();
     RSInterfaces::GetInstance().TakeSurfaceCapture(surfaceNode_, callback);
     std::shared_ptr<Media::PixelMap> pixelMap = callback->GetResult(2000); // wait for <= 2000ms
@@ -711,7 +711,7 @@ void WindowImpl::GetConfigurationFromAbilityInfo()
         WLOGFD("mode config param is 0, all modes is supported");
         modeSupportInfo = WindowModeSupport::WINDOW_MODE_SUPPORT_ALL;
     }
-    WLOGFI("winId: %{public}u, modeSupportInfo: %{public}u", GetWindowId(), modeSupportInfo);
+    WLOGFD("winId: %{public}u, modeSupportInfo: %{public}u", GetWindowId(), modeSupportInfo);
     SetRequestModeSupportInfo(modeSupportInfo);
 
     // get window size limits configuration
@@ -1109,7 +1109,7 @@ WMError WindowImpl::Show(uint32_t reason, bool withAnimation)
 
 WMError WindowImpl::Hide(uint32_t reason, bool withAnimation)
 {
-    WLOGFI("[Client] Window [name:%{public}s, id:%{public}u] Hide, reason:%{public}u, withAnimation:%{public}d",
+    WLOGFD("[Client] Window [name:%{public}s, id:%{public}u] Hide, reason:%{public}u, withAnimation:%{public}d",
         name_.c_str(), property_->GetWindowId(), reason, withAnimation);
     if (!IsWindowValid()) {
         return WMError::WM_ERROR_INVALID_WINDOW;
@@ -1153,7 +1153,7 @@ WMError WindowImpl::Hide(uint32_t reason, bool withAnimation)
 
 WMError WindowImpl::MoveTo(int32_t x, int32_t y)
 {
-    WLOGFI("[Client] Window [name:%{public}s, id:%{public}d] MoveTo %{public}d %{public}d",
+    WLOGFD("[Client] Window [name:%{public}s, id:%{public}d] MoveTo %{public}d %{public}d",
         name_.c_str(), property_->GetWindowId(), x, y);
     if (!IsWindowValid()) {
         return WMError::WM_ERROR_INVALID_WINDOW;
@@ -1172,7 +1172,7 @@ WMError WindowImpl::MoveTo(int32_t x, int32_t y)
 
 WMError WindowImpl::Resize(uint32_t width, uint32_t height)
 {
-    WLOGFI("[Client] Window [name:%{public}s, id:%{public}d] Resize %{public}u %{public}u",
+    WLOGFD("[Client] Window [name:%{public}s, id:%{public}d] Resize %{public}u %{public}u",
         name_.c_str(), property_->GetWindowId(), width, height);
     if (!IsWindowValid()) {
         return WMError::WM_ERROR_INVALID_WINDOW;
@@ -1400,7 +1400,7 @@ void WindowImpl::DisableAppWindowDecor()
 
 bool WindowImpl::IsDecorEnable() const
 {
-    WLOGFE("get decor enable %{public}d", property_->GetDecorEnable());
+    WLOGFD("get decor enable %{public}d", property_->GetDecorEnable());
     return property_->GetDecorEnable();
 }
 
@@ -1823,7 +1823,7 @@ void WindowImpl::UpdateRect(const struct Rect& rect, bool decoStatus, WindowSize
         property_->SetOriginRect(rect);
         isOriginRectSet_ = true;
     }
-    WLOGFI("winId:%{public}u, rect[%{public}d, %{public}d, %{public}u, %{public}u], reason:%{public}u",
+    WLOGFD("winId:%{public}u, rect[%{public}d, %{public}d, %{public}u, %{public}u], reason:%{public}u",
         property_->GetWindowId(), rect.posX_, rect.posY_, rect.width_, rect.height_, reason);
     Rect rectToAce = rect;
     // update rectToAce for stretchable window
@@ -2435,7 +2435,7 @@ void WindowImpl::UpdateOccupiedAreaChangeInfo(const sptr<OccupiedAreaChangeInfo>
 
 void WindowImpl::UpdateActiveStatus(bool isActive)
 {
-    WLOGFI("window active status: %{public}d, id: %{public}u", isActive, property_->GetWindowId());
+    WLOGFD("window active status: %{public}d, id: %{public}u", isActive, property_->GetWindowId());
     if (isActive) {
         NotifyAfterActive();
     } else {
diff --git a/wm/src/window_manager.cpp b/wm/src/window_manager.cpp
index b196add2b199ccde35ab9de8ccbcbf30bd7c1d32..354a061bbd30476d1434988763c97e9ca1c5cb3b 100644
--- a/wm/src/window_manager.cpp
+++ b/wm/src/window_manager.cpp
@@ -204,7 +204,7 @@ void WindowManager::Impl::InitListenerHandler()
 
 void WindowManager::Impl::NotifyFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
 {
-    WLOGFI("NotifyFocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u; %{public}p]",
+    WLOGFD("NotifyFocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u; %{public}p]",
         focusChangeInfo->windowId_, focusChangeInfo->displayId_, focusChangeInfo->pid_, focusChangeInfo->uid_,
         static_cast<uint32_t>(focusChangeInfo->windowType_), focusChangeInfo->abilityToken_.GetRefPtr());
     std::vector<sptr<IFocusChangedListener>> focusChangeListeners;
@@ -221,7 +221,7 @@ void WindowManager::Impl::NotifyFocused(const sptr<FocusChangeInfo>& focusChange
 
 void WindowManager::Impl::NotifyUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
 {
-    WLOGFI("NotifyUnfocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u; %{public}p]",
+    WLOGFD("NotifyUnfocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u; %{public}p]",
         focusChangeInfo->windowId_, focusChangeInfo->displayId_, focusChangeInfo->pid_, focusChangeInfo->uid_,
         static_cast<uint32_t>(focusChangeInfo->windowType_), focusChangeInfo->abilityToken_.GetRefPtr());
     std::vector<sptr<IFocusChangedListener>> focusChangeListeners;
@@ -239,7 +239,7 @@ void WindowManager::Impl::NotifyUnfocused(const sptr<FocusChangeInfo>& focusChan
 void WindowManager::Impl::NotifySystemBarChanged(DisplayId displayId, const SystemBarRegionTints& tints)
 {
     for (auto tint : tints) {
-        WLOGFI("type:%{public}d, enable:%{public}d," \
+        WLOGFD("type:%{public}d, enable:%{public}d," \
             "backgroundColor:%{public}x, contentColor:%{public}x " \
             "region:[%{public}d, %{public}d, %{public}d, %{public}d]",
             tint.type_, tint.prop_.enable_, tint.prop_.backgroundColor_, tint.prop_.contentColor_,
@@ -264,7 +264,7 @@ void WindowManager::Impl::NotifyAccessibilityWindowInfo(const sptr<Accessibility
         WLOGFE("windowInfo is nullptr");
         return;
     }
-    WLOGFI("NotifyAccessibilityWindowInfo: wid[%{public}d], width[%{public}d]," \
+    WLOGFD("NotifyAccessibilityWindowInfo: wid[%{public}d], width[%{public}d]," \
         "height[%{public}d], positionX[%{public}d], positionY[%{public}d]," \
         "isFocused[%{public}d], isDecorEnable[%{public}d], displayId[%{public}" PRIu64"]," \
         "mode[%{public}d], type[%{public}d]",
@@ -302,7 +302,7 @@ void WindowManager::Impl::NotifyWindowVisibilityInfoChanged(
 
 void WindowManager::Impl::UpdateCameraFloatWindowStatus(uint32_t accessTokenId, bool isShowing)
 {
-    WLOGFI("Camera float window, accessTokenId = %{public}u, isShowing = %{public}u", accessTokenId, isShowing);
+    WLOGFD("Camera float window, accessTokenId = %{public}u, isShowing = %{public}u", accessTokenId, isShowing);
     std::vector<sptr<ICameraFloatWindowChangedListener>> cameraFloatWindowChangeListeners;
     {
         std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -327,7 +327,7 @@ void WindowManager::RegisterFocusChangedListener(const sptr<IFocusChangedListene
     std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
     auto iter = std::find(pImpl_->focusChangedListeners_.begin(), pImpl_->focusChangedListeners_.end(), listener);
     if (iter != pImpl_->focusChangedListeners_.end()) {
-        WLOGFI("Listener is already registered.");
+        WLOGFW("Listener is already registered.");
         return;
     }
     pImpl_->focusChangedListeners_.push_back(listener);
@@ -370,7 +370,7 @@ void WindowManager::RegisterSystemBarChangedListener(const sptr<ISystemBarChange
     auto iter = std::find(pImpl_->systemBarChangedListeners_.begin(), pImpl_->systemBarChangedListeners_.end(),
         listener);
     if (iter != pImpl_->systemBarChangedListeners_.end()) {
-        WLOGFI("Listener is already registered.");
+        WLOGFW("Listener is already registered.");
         return;
     }
     pImpl_->systemBarChangedListeners_.push_back(listener);
@@ -405,19 +405,19 @@ void WindowManager::UnregisterSystemBarChangedListener(const sptr<ISystemBarChan
 
 void WindowManager::MinimizeAllAppWindows(DisplayId displayId)
 {
-    WLOGFI("displayId %{public}" PRIu64"", displayId);
+    WLOGFD("displayId %{public}" PRIu64"", displayId);
     SingletonContainer::Get<WindowAdapter>().MinimizeAllAppWindows(displayId);
 }
 
 WMError WindowManager::ToggleShownStateForAllAppWindows()
 {
-    WLOGFI("ToggleShownStateForAllAppWindows");
+    WLOGFD("ToggleShownStateForAllAppWindows");
     return SingletonContainer::Get<WindowAdapter>().ToggleShownStateForAllAppWindows();
 }
 
 WMError WindowManager::SetWindowLayoutMode(WindowLayoutMode mode)
 {
-    WLOGFI("set window layout mode: %{public}u", mode);
+    WLOGFD("set window layout mode: %{public}u", mode);
     WMError ret  = SingletonContainer::Get<WindowAdapter>().SetWindowLayoutMode(mode);
     if (ret != WMError::WM_OK) {
         WLOGFE("set layout mode failed");
@@ -475,7 +475,7 @@ void WindowManager::RegisterVisibilityChangedListener(const sptr<IVisibilityChan
     auto iter = std::find(pImpl_->windowVisibilityListeners_.begin(), pImpl_->windowVisibilityListeners_.end(),
         listener);
     if (iter != pImpl_->windowVisibilityListeners_.end()) {
-        WLOGFI("Listener is already registered.");
+        WLOGFW("Listener is already registered.");
         return;
     }
     pImpl_->windowVisibilityListeners_.emplace_back(listener);
@@ -517,7 +517,7 @@ void WindowManager::RegisterCameraFloatWindowChangedListener(const sptr<ICameraF
     auto iter = std::find(pImpl_->cameraFloatWindowChangedListeners_.begin(),
         pImpl_->cameraFloatWindowChangedListeners_.end(), listener);
     if (iter != pImpl_->cameraFloatWindowChangedListeners_.end()) {
-        WLOGFI("Listener is already registered.");
+        WLOGFW("Listener is already registered.");
         return;
     }
     pImpl_->cameraFloatWindowChangedListeners_.push_back(listener);
@@ -559,7 +559,7 @@ void WindowManager::UpdateFocusChangeInfo(const sptr<FocusChangeInfo>& focusChan
         WLOGFE("focusChangeInfo is nullptr.");
         return;
     }
-    WLOGFI("window focus change: %{public}d, id: %{public}u", focused, focusChangeInfo->windowId_);
+    WLOGFD("window focus change: %{public}d, id: %{public}u", focused, focusChangeInfo->windowId_);
     if (focused) {
         pImpl_->NotifyFocused(focusChangeInfo);
     } else {