openharmony/windowmanager
1
0
Fork 0
mirror of https://github.com/openharmony/windowmanager.git synced 2026-07-18 16:24:27 -04:00
Code Issues Packages Projects Releases Wiki Activity

!1236 use MinimizeAbility asynchronously

Browse Source 
Merge pull request !1236 from 邢亚楠/minimize_dev
This commit is contained in:
openharmony_ci
2022-07-30 03:16:20 +00:00
committed by Gitee
parent bae8eb2ed0 925bd1dbcf
commit 4b4a83015b
4 changed files with 69 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
wmserver/include/window_inner_manager.h
+8 -1
View File
@@ -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<void()>;
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<WindowNode> &node, bool isFromUser);
void ConsumePointerEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent);
bool NotifyWindowReadyToMoveOrDrag(uint32_t windowId, sptr<WindowProperty>& windowProperty,
wmserver/src/minimize_app.cpp
+3 -16
View File
@@ -17,6 +17,7 @@
#include <ability_manager_client.h>
#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();
}
wmserver/src/remote_animation.cpp
+4 -8
View File
@@ -21,6 +21,7 @@
#include <rs_window_animation_finished_callback.h>
#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<WindowTransitionInfo> srcI
windowRoot->RemoveWindowNode(srcNode->GetWindowId());
wptr<WindowNode> 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<int32_t>(TraceTaskId::REMOTE_ANIMATION),
"wms:async:ShowRemoteAnimation");
AAFwk::AbilityManagerClient::GetInstance()->MinimizeAbility(weakNode->abilityToken_, true);
}
FinishAsyncTraceArgs(HITRACE_TAG_WINDOW_MANAGER, static_cast<int32_t>(TraceTaskId::REMOTE_ANIMATION),
"wms:async:ShowRemoteAnimation");
WindowInnerManager::GetInstance().MinimizeAbility(weak, true);
};
sptr<RSWindowAnimationFinishedCallback> finishedCallback = new(std::nothrow) RSWindowAnimationFinishedCallback(
minimizeFunc);
wmserver/src/window_inner_manager.cpp
+54 -10
View File
@@ -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<WindowNode> &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<IRemoteObject> 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;
}