From 925bd1dbcfd20a40ab6c1fc791dfa1d85f71ce84 Mon Sep 17 00:00:00 2001 From: xingyanan Date: Fri, 29 Jul 2022 17:34:44 +0800 Subject: [PATCH] use MinimizeAbility asynchronously Signed-off-by: xingyanan Change-Id: Ia89808f435883f366aa12f50483f471f550c4487 Signed-off-by: xingyanan --- wmserver/include/window_inner_manager.h | 9 +++- wmserver/src/minimize_app.cpp | 19 ++------ wmserver/src/remote_animation.cpp | 12 ++--- wmserver/src/window_inner_manager.cpp | 64 +++++++++++++++++++++---- 4 files changed, 69 insertions(+), 35 deletions(-) diff --git a/wmserver/include/window_inner_manager.h b/wmserver/include/window_inner_manager.h index fa4982cb..90d438d1 100644 --- a/wmserver/include/window_inner_manager.h +++ b/wmserver/include/window_inner_manager.h @@ -23,6 +23,7 @@ #include "drag_controller.h" #include "inner_window.h" #include "wm_common.h" +#include "window_node.h" #include "wm_single_instance.h" enum class InnerWMRunningState { @@ -31,9 +32,10 @@ enum class InnerWMRunningState { }; namespace OHOS { namespace Rosen { +using InnerTask = std::function; using EventRunner = OHOS::AppExecFwk::EventRunner; using EventHandler = OHOS::AppExecFwk::EventHandler; - +using EventPriority = OHOS::AppExecFwk::EventQueue::Priority; class WindowInnerManager : public RefBase { WM_DECLARE_SINGLE_INSTANCE_BASE(WindowInnerManager); public: @@ -42,6 +44,11 @@ public: void CreateInnerWindow(std::string name, DisplayId displayId, Rect rect, WindowType type, WindowMode mode); void DestroyInnerWindow(DisplayId displayId, WindowType type); void UpdateInnerWindow(DisplayId displayId, WindowType type, uint32_t width, uint32_t height); + void PostTask(InnerTask &&callback, std::string name = "WindowInnerManagerTask", + EventPriority priority = EventPriority::LOW); + + // asynchronously calls the functions of AbilityManager + void MinimizeAbility(const wptr &node, bool isFromUser); void ConsumePointerEvent(const std::shared_ptr& pointerEvent); bool NotifyWindowReadyToMoveOrDrag(uint32_t windowId, sptr& windowProperty, diff --git a/wmserver/src/minimize_app.cpp b/wmserver/src/minimize_app.cpp index 387d0e44..f7bc6838 100644 --- a/wmserver/src/minimize_app.cpp +++ b/wmserver/src/minimize_app.cpp @@ -17,6 +17,7 @@ #include #include "window_manager_hilog.h" +#include "window_inner_manager.h" namespace OHOS { namespace Rosen { @@ -60,17 +61,7 @@ void MinimizeApp::ExecuteMinimizeAll() WLOGFI("[Minimize] ExecuteMinimizeAll with size: %{public}zu, reason: %{public}u", appNodes.second.size(), appNodes.first); for (auto& node : appNodes.second) { - auto weakNode = node.promote(); - if (weakNode != nullptr && weakNode->abilityToken_ != nullptr && !weakNode->startingWindowShown_) { - WLOGFI("[Minimize] Minimize Window %{public}u, reason %{public}u", - weakNode->GetWindowId(), appNodes.first); - AAFwk::AbilityManagerClient::GetInstance()->MinimizeAbility(weakNode->abilityToken_, isFromUser); - } else if (weakNode != nullptr) { - WLOGFI("window is not minimize since id:%{public}u, " - "startingWindowShown_:%{public}d, abilityToken:%{public}d, windowToken:%{public}d", - weakNode->GetWindowId(), weakNode->startingWindowShown_, weakNode->abilityToken_ != nullptr, - weakNode->GetWindowToken() != nullptr); - } + WindowInnerManager::GetInstance().MinimizeAbility(node, isFromUser); } appNodes.second.clear(); } @@ -122,11 +113,7 @@ void MinimizeApp::ExecuteMinimizeTargetReason(MinimizeReason reason) if (needMinimizeAppNodes_.find(reason) != needMinimizeAppNodes_.end()) { bool isFromUser = IsFromUser(reason); for (auto& node : needMinimizeAppNodes_.at(reason)) { - auto weakNode = node.promote(); - if (weakNode != nullptr && weakNode->abilityToken_ != nullptr && !weakNode->startingWindowShown_) { - WLOGFI("[Minimize] Minimize Window %{public}u, reason %{public}u", weakNode->GetWindowId(), reason); - AAFwk::AbilityManagerClient::GetInstance()->MinimizeAbility(weakNode->abilityToken_, isFromUser); - } + WindowInnerManager::GetInstance().MinimizeAbility(node, isFromUser); } needMinimizeAppNodes_.at(reason).clear(); } diff --git a/wmserver/src/remote_animation.cpp b/wmserver/src/remote_animation.cpp index d661e4a5..692b46a5 100644 --- a/wmserver/src/remote_animation.cpp +++ b/wmserver/src/remote_animation.cpp @@ -21,6 +21,7 @@ #include #include "minimize_app.h" #include "window_helper.h" +#include "window_inner_manager.h" #include "window_manager_hilog.h" namespace OHOS { @@ -190,14 +191,9 @@ WMError RemoteAnimation::NotifyAnimationMinimize(sptr srcI windowRoot->RemoveWindowNode(srcNode->GetWindowId()); wptr weak = srcNode; auto minimizeFunc = [weak]() { - auto weakNode = weak.promote(); - if (weakNode != nullptr && weakNode->abilityToken_ != nullptr) { - WLOGFI("minimize windowId: %{public}u, name:%{public}s", - weakNode->GetWindowId(), weakNode->GetWindowName().c_str()); - FinishAsyncTraceArgs(HITRACE_TAG_WINDOW_MANAGER, static_cast(TraceTaskId::REMOTE_ANIMATION), - "wms:async:ShowRemoteAnimation"); - AAFwk::AbilityManagerClient::GetInstance()->MinimizeAbility(weakNode->abilityToken_, true); - } + FinishAsyncTraceArgs(HITRACE_TAG_WINDOW_MANAGER, static_cast(TraceTaskId::REMOTE_ANIMATION), + "wms:async:ShowRemoteAnimation"); + WindowInnerManager::GetInstance().MinimizeAbility(weak, true); }; sptr finishedCallback = new(std::nothrow) RSWindowAnimationFinishedCallback( minimizeFunc); diff --git a/wmserver/src/window_inner_manager.cpp b/wmserver/src/window_inner_manager.cpp index 4921e2c3..7a008f88 100644 --- a/wmserver/src/window_inner_manager.cpp +++ b/wmserver/src/window_inner_manager.cpp @@ -15,9 +15,10 @@ #include "window_inner_manager.h" +#include "ability_manager_client.h" #include "ui_service_mgr_client.h" -#include "window_manager_hilog.h" #include "window.h" +#include "window_manager_hilog.h" namespace OHOS { namespace Rosen { @@ -92,10 +93,11 @@ void WindowInnerManager::Stop() void WindowInnerManager::CreateInnerWindow(std::string name, DisplayId displayId, Rect rect, WindowType type, WindowMode mode) { - eventHandler_->PostTask([this, name, displayId, rect, mode, type]() { + bool recentHolderWindowFlag = isRecentHolderEnable_; + auto task = [name, displayId, rect, mode, type, recentHolderWindowFlag]() { switch (type) { case WindowType::WINDOW_TYPE_PLACEHOLDER: { - if (isRecentHolderEnable_) { + if (recentHolderWindowFlag) { PlaceHolderWindow::GetInstance().Create(name, displayId, rect, mode); } break; @@ -108,16 +110,18 @@ void WindowInnerManager::CreateInnerWindow(std::string name, DisplayId displayId default: break; } - }); + }; + PostTask(task, "CreateInnerWindow"); return; } void WindowInnerManager::DestroyInnerWindow(DisplayId displayId, WindowType type) { - eventHandler_->PostTask([this, type]() { + bool recentHolderWindowFlag = isRecentHolderEnable_; + auto task = [type, recentHolderWindowFlag]() { switch (type) { case WindowType::WINDOW_TYPE_PLACEHOLDER: { - if (isRecentHolderEnable_) { + if (recentHolderWindowFlag) { PlaceHolderWindow::GetInstance().Destroy(); } break; @@ -129,16 +133,18 @@ void WindowInnerManager::DestroyInnerWindow(DisplayId displayId, WindowType type default: break; } - }); + }; + PostTask(task, "DestroyInnerWindow"); return; } void WindowInnerManager::UpdateInnerWindow(DisplayId displayId, WindowType type, uint32_t width, uint32_t height) { - eventHandler_->PostTask([this, type, width, height]() { + bool recentHolderWindowFlag = isRecentHolderEnable_; + auto task = [type, width, height, recentHolderWindowFlag]() { switch (type) { case WindowType::WINDOW_TYPE_PLACEHOLDER: { - if (isRecentHolderEnable_) { + if (recentHolderWindowFlag) { PlaceHolderWindow::GetInstance().Update(width, height); } break; @@ -150,7 +156,45 @@ void WindowInnerManager::UpdateInnerWindow(DisplayId displayId, WindowType type, default: break; } - }); + }; + PostTask(task, "UpdateInnerWindow"); + return; +} + +void WindowInnerManager::MinimizeAbility(const wptr &node, bool isFromUser) +{ + // asynchronously calls the MinimizeAbility of AbilityManager + auto weakNode = node.promote(); + if (weakNode == nullptr || weakNode->startingWindowShown_) { + WLOGE("minimize ability failed, because node is nullptr or start window node."); + return; + } + wptr weakToken(weakNode->abilityToken_); + WLOGFD("minimize window %{public}u, isfromuser: %{public}d", weakNode->GetWindowId(), isFromUser); + auto task = [weakToken, isFromUser]() { + auto token = weakToken.promote(); + if (token == nullptr) { + WLOGE("minimize ability failed, because window token is nullptr."); + return; + } + AAFwk::AbilityManagerClient::GetInstance()->MinimizeAbility(token, isFromUser); + }; + PostTask(task, "MinimizeAbility"); +} + +void WindowInnerManager::PostTask(InnerTask &&task, std::string name, EventPriority priority) +{ + if (eventHandler_ == nullptr) { + WLOGFE("listener handler is nullptr"); + return; + } + bool ret = eventHandler_->PostTask([task]() { + task(); + }, name, 0, priority); // 0 is task delay time + if (!ret) { + WLOGFE("post listener callback task failed."); + return; + } return; }