openharmony/window_window_manager
1
0
Fork 0
mirror of https://gitee.com/openharmony/window_window_manager synced 2024-11-24 07:20:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

log level fix

Browse Source 
Signed-off-by: xingyanan <xingyanan2@huawei.com>
Change-Id: Id2b92fa3294733fffc60bc93d8e073792112d680
This commit is contained in:
xingyanan 2022-08-31 01:37:21 +00:00
parent 3b6aeecd1b
commit 1ef0a237af
4 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
dm/src/display_manager.cpp
View File

@ -485,7 +485,7 @@ bool DisplayManager::Impl::RegisterDisplayPowerEventListener(sptr<IDisplayPowerE
} else {
powerEventListeners_.insert(listener);
}
WLOGFI("RegisterDisplayPowerEventListener end");
WLOGFD("RegisterDisplayPowerEventListener end");
return ret;
}
@ -514,7 +514,7 @@ bool DisplayManager::Impl::UnregisterDisplayPowerEventListener(sptr<IDisplayPowe
DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER);
powerEventListenerAgent_ = nullptr;
}
WLOGFI("UnregisterDisplayPowerEventListener end");
WLOGFD("UnregisterDisplayPowerEventListener end");
return ret;
}
@ -585,7 +585,7 @@ bool DisplayManager::UnregisterScreenshotListener(sptr<IScreenshotListener> list
void DisplayManager::Impl::NotifyScreenshot(sptr<ScreenshotInfo> info)
{
WLOGFI("NotifyScreenshot trigger:[%{public}s] displayId:%{public}" PRIu64" size:%{public}zu",
WLOGFD("NotifyScreenshot trigger:[%{public}s] displayId:%{public}" PRIu64" size:%{public}zu",
info->GetTrigger().c_str(), info->GetDisplayId(), screenshotListeners_.size());
std::set<sptr<IScreenshotListener>> screenshotListeners;
{
@ -599,7 +599,7 @@ void DisplayManager::Impl::NotifyScreenshot(sptr<ScreenshotInfo> info)
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;
{
@ -613,7 +613,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_);
@ -635,7 +635,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);
}
@ -653,14 +653,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;
}
@ -671,32 +671,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_);
@ -732,7 +732,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;
}
@ -747,7 +747,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);
}

14
wm/src/input_transfer_station.cpp
View File

@ -35,7 +35,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");
@ -50,7 +50,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();
}
@ -77,7 +77,7 @@ 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);
// INPUT_WINDOW_TYPE_SKIPPED should not set input consumer
if (INPUT_WINDOW_TYPE_SKIPPED.find(window->GetType()) != INPUT_WINDOW_TYPE_SKIPPED.end()) {
@ -88,14 +88,14 @@ void InputTransferStation::AddInputWindow(const sptr<Window>& window)
std::lock_guard<std::mutex> lock(mtx_);
windowInputChannels_.insert(std::make_pair(windowId, inputChannel));
if (inputListener_ == nullptr) {
WLOGFI("Init input listener, IsMainHandlerAvailable: %{public}u", window->IsMainHandlerAvailable());
WLOGFD("Init input listener, IsMainHandlerAvailable: %{public}u", window->IsMainHandlerAvailable());
std::shared_ptr<MMI::IInputEventConsumer> listener = std::make_shared<InputEventListener>(InputEventListener());
auto mainEventRunner = AppExecFwk::EventRunner::GetMainEventRunner();
if (mainEventRunner != nullptr && window->IsMainHandlerAvailable()) {
WLOGFI("MainEventRunner is available");
WLOGFD("MainEventRunner is available");
eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(mainEventRunner);
} else {
WLOGFI("MainEventRunner is not available");
WLOGFD("MainEventRunner is not available");
eventHandler_ = AppExecFwk::EventHandler::Current();
auto curThreadId = std::this_thread::get_id();
if (!eventHandler_ || (mainEventRunner->GetThreadId() == *(reinterpret_cast<uint64_t*>(&curThreadId)))) {
@ -112,7 +112,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_);

24
wm/src/window_impl.cpp
View File

@ -323,7 +323,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;
}
@ -738,7 +738,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
@ -817,7 +817,7 @@ void WindowImpl::SetWindowCornerRadiusAccordingToSystemConfig()
auto splitRadius = windowSystemConfig_.effectConfig_.splitCornerRadius_ * vpr;
auto floatRadius = windowSystemConfig_.effectConfig_.floatCornerRadius_ * vpr;
WLOGFI("[WEffect] [name:%{public}s] mode: %{public}u, vpr: %{public}f, [%{public}f, %{public}f, %{public}f]",
WLOGFD("[WEffect] [name:%{public}s] mode: %{public}u, vpr: %{public}f, [%{public}f, %{public}f, %{public}f]",
name_.c_str(), GetMode(), vpr, fullscreenRadius, splitRadius, floatRadius);
if (WindowHelper::IsFullScreenWindow(GetMode()) && MathHelper::GreatNotEqual(fullscreenRadius, 0.0)) {
@ -880,13 +880,13 @@ void WindowImpl::SetSystemConfig()
}
if (SingletonContainer::Get<WindowAdapter>().GetSystemConfig(windowSystemConfig_) == WMError::WM_OK) {
if (WindowHelper::IsMainWindow(property_->GetWindowType())) {
WLOGFI("get system decor enable:%{public}d", windowSystemConfig_.isSystemDecorEnable_);
WLOGFD("get system decor enable:%{public}d", windowSystemConfig_.isSystemDecorEnable_);
property_->SetDecorEnable(windowSystemConfig_.isSystemDecorEnable_);
WLOGFI("get stretchable enable:%{public}d", windowSystemConfig_.isStretchable_);
WLOGFD("get stretchable enable:%{public}d", windowSystemConfig_.isStretchable_);
property_->SetStretchable(windowSystemConfig_.isStretchable_);
// if window mode is undefined, set it from configuration
if (property_->GetWindowMode() == WindowMode::WINDOW_MODE_UNDEFINED) {
WLOGFI("get default window mode:%{public}u", windowSystemConfig_.defaultWindowMode_);
WLOGFD("get default window mode:%{public}u", windowSystemConfig_.defaultWindowMode_);
property_->SetWindowMode(windowSystemConfig_.defaultWindowMode_);
}
if (property_->GetLastWindowMode() == WindowMode::WINDOW_MODE_UNDEFINED) {
@ -1203,7 +1203,7 @@ WMError WindowImpl::PreProcessShow(uint32_t reason, bool withAnimation)
WMError WindowImpl::Show(uint32_t reason, bool withAnimation)
{
WLOGFI("[Client] Window Show [name:%{public}s, id:%{public}u, mode: %{public}u], reason:%{public}u, "
WLOGFD("[Client] Window Show [name:%{public}s, id:%{public}u, mode: %{public}u], reason:%{public}u, "
"withAnimation:%{public}d", name_.c_str(), property_->GetWindowId(), GetMode(), reason, withAnimation);
if (!IsWindowValid()) {
return WMError::WM_ERROR_INVALID_WINDOW;
@ -1554,7 +1554,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();
}
@ -2010,7 +2010,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
@ -2031,7 +2031,7 @@ void WindowImpl::UpdateRect(const struct Rect& rect, bool decoStatus, WindowSize
return;
}
Ace::ViewportConfig config;
WLOGFI("UpdateViewportConfig Id:%{public}u, windowRect:[%{public}d, %{public}d, %{public}u, %{public}u]",
WLOGFD("UpdateViewportConfig Id:%{public}u, windowRect:[%{public}d, %{public}d, %{public}u, %{public}u]",
property_->GetWindowId(), rectToAce.posX_, rectToAce.posY_, rectToAce.width_, rectToAce.height_);
config.SetSize(rectToAce.width_, rectToAce.height_);
config.SetPosition(rectToAce.posX_, rectToAce.posY_);
@ -2453,7 +2453,7 @@ void WindowImpl::RequestVsync(const std::shared_ptr<VsyncCallback>& vsyncCallbac
void WindowImpl::UpdateFocusStatus(bool focused)
{
WLOGFI("window focus status: %{public}d, id: %{public}u", focused, property_->GetWindowId());
WLOGFD("window focus status: %{public}d, id: %{public}u", focused, property_->GetWindowId());
if (focused) {
NotifyAfterFocused();
} else {
@ -2577,7 +2577,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 {

24
wm/src/window_manager.cpp
View File

@ -187,7 +187,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;
@ -204,7 +204,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;
@ -222,7 +222,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_,
@ -248,7 +248,7 @@ void WindowManager::Impl::NotifyAccessibilityWindowInfo(const std::vector<sptr<A
return;
}
for (auto& info : infos) {
WLOGFI("NotifyAccessibilityWindowInfo: wid[%{public}u], rect[%{public}d %{public}d %{public}d %{public}d]," \
WLOGFD("NotifyAccessibilityWindowInfo: wid[%{public}u], rect[%{public}d %{public}d %{public}d %{public}d]," \
"isFocused[%{public}d], isDecorEnable[%{public}d], displayId[%{public}" PRIu64"], layer[%{public}u]," \
"mode[%{public}u], type[%{public}u, updateType[%{public}d]",
info->wid_, info->windowRect_.width_, info->windowRect_.height_, info->windowRect_.posX_,
@ -285,7 +285,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_);
@ -310,7 +310,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);
@ -353,7 +353,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);
@ -388,19 +388,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");
@ -458,7 +458,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);
@ -500,7 +500,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);