From 10c444f1d277d726b21c1649195925e0dbfd447a Mon Sep 17 00:00:00 2001 From: chyyy0213 Date: Sat, 9 Jul 2022 14:35:17 +0800 Subject: [PATCH] add animation js interface Signed-off-by: chyyy0213 Change-Id: I4f1bc6676bed6d6ce22b67d9da249a0155e76382 Signed-off-by: chyyy0213 --- dm/test/systemtest/display_power_test.cpp | 4 +- interfaces/innerkits/wm/window.h | 2 +- interfaces/innerkits/wm/wm_common.h | 11 + interfaces/kits/napi/window_runtime/BUILD.gn | 1 + .../napi/window_runtime/api/@ohos.window.d.ts | 112 ++++++-- .../window_napi/js_transition_controller.cpp | 250 ++++++++++++++++++ .../window_napi/js_transition_controller.h | 54 ++++ .../window_runtime/window_napi/js_window.cpp | 169 +++++++++++- .../window_runtime/window_napi/js_window.h | 9 + .../window_napi/js_window_utils.cpp | 4 +- .../window_napi/js_window_utils.h | 2 +- .../window_stage_napi/js_window_stage.cpp | 1 + utils/include/wm_common_inner.h | 11 - wm/include/window_impl.h | 2 +- wm/src/window_impl.cpp | 41 ++- .../window_app_floating_window_test.cpp | 20 +- wm/test/unittest/window_impl_test.cpp | 12 +- wmserver/src/zidl/window_manager_proxy.cpp | 2 +- 18 files changed, 621 insertions(+), 86 deletions(-) create mode 100644 interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.cpp create mode 100644 interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.h diff --git a/dm/test/systemtest/display_power_test.cpp b/dm/test/systemtest/display_power_test.cpp index 6c1553d3e2..cfafbccdf0 100644 --- a/dm/test/systemtest/display_power_test.cpp +++ b/dm/test/systemtest/display_power_test.cpp @@ -422,11 +422,11 @@ HWTEST_F(DisplayPowerTest, window_life_cycle_001, Function | MediumTest | Level2 DisplayManager::GetInstance().SuspendBegin(PowerStateChangeReason::POWER_BUTTON); usleep(SLEEP_TIME_IN_US); - ASSERT_EQ(false, window->GetShowState()); + ASSERT_EQ(false, window->GetWindowState() == WindowState::STATE_SHOWN); DisplayManager::GetInstance().NotifyDisplayEvent(DisplayEvent::UNLOCK); usleep(SLEEP_TIME_IN_US); - ASSERT_EQ(true, window->GetShowState()); + ASSERT_EQ(true, window->GetWindowState() == WindowState::STATE_SHOWN); window->Destroy(); } diff --git a/interfaces/innerkits/wm/window.h b/interfaces/innerkits/wm/window.h index 939913fa5c..bfe4fd7d31 100644 --- a/interfaces/innerkits/wm/window.h +++ b/interfaces/innerkits/wm/window.h @@ -173,7 +173,7 @@ public: virtual const std::string& GetWindowName() const = 0; virtual uint32_t GetWindowId() const = 0; virtual uint32_t GetWindowFlags() const = 0; - virtual bool GetShowState() const = 0; + virtual WindowState GetWindowState() const = 0; virtual WMError SetFocusable(bool isFocusable) = 0; virtual bool GetFocusable() const = 0; virtual WMError SetTouchable(bool isTouchable) = 0; diff --git a/interfaces/innerkits/wm/wm_common.h b/interfaces/innerkits/wm/wm_common.h index e7b5805b0f..618baa11b9 100644 --- a/interfaces/innerkits/wm/wm_common.h +++ b/interfaces/innerkits/wm/wm_common.h @@ -96,6 +96,17 @@ enum class WindowBlurLevel : uint32_t { WINDOW_BLUR_HIGH }; +enum class WindowState : uint32_t { + STATE_INITIAL, + STATE_CREATED, + STATE_SHOWN, + STATE_HIDDEN, + STATE_FROZEN, + STATE_DESTROYED, + STATE_BOTTOM = STATE_DESTROYED, + STATE_UNFROZEN, +}; + enum class WMError : int32_t { WM_OK = 0, WM_DO_NOTHING, diff --git a/interfaces/kits/napi/window_runtime/BUILD.gn b/interfaces/kits/napi/window_runtime/BUILD.gn index cf31cde7a2..f141e3fea4 100644 --- a/interfaces/kits/napi/window_runtime/BUILD.gn +++ b/interfaces/kits/napi/window_runtime/BUILD.gn @@ -42,6 +42,7 @@ config("window_native_kit_config") { ohos_shared_library("window_native_kit") { sources = [ + "window_napi/js_transition_controller.cpp", "window_napi/js_window.cpp", "window_napi/js_window_listener.cpp", "window_napi/js_window_register_manager.cpp", diff --git a/interfaces/kits/napi/window_runtime/api/@ohos.window.d.ts b/interfaces/kits/napi/window_runtime/api/@ohos.window.d.ts index 55fe7e347b..f5fbf52a76 100644 --- a/interfaces/kits/napi/window_runtime/api/@ohos.window.d.ts +++ b/interfaces/kits/napi/window_runtime/api/@ohos.window.d.ts @@ -617,6 +617,20 @@ declare namespace window { */ hide(): Promise; + /** + * hide window with animation. + * @since 9 + * @systemapi + */ + hideWithAnimation(callback: AsyncCallback): void; + + /** + * hide window with animation. + * @since 9 + * @systemapi + */ + hideWithAnimation(): Promise; + /** * show sub window. * @since 7 @@ -624,11 +638,25 @@ declare namespace window { show(callback: AsyncCallback): void; /** - * show sub window. + * show window. * @since 7 */ show(): Promise; + /** + * show window with animation. + * @since 9 + * @systemapi + */ + showWithAnimation(callback: AsyncCallback): void; + + /** + * show window with animation. + * @since 9 + * @systemapi + */ + showWithAnimation(): Promise; + /** * Destroy the sub window. * @since 7 @@ -1072,33 +1100,75 @@ declare namespace window { */ setForbidSplitMove(isForbidSplitMove: boolean): Promise; /** - * Sets opacity of window - * @param opacity Interval is 0.f-1.f. - * @systemapi - * @since 9 - */ + * Sets opacity of window + * @param opacity Interval is 0.f-1.f. + * @systemapi + * @since 9 + */ setOpacitySync(opacity: number): void; /** - * Sets scale options of window. - * @param scaleOptions scale param of window. - * @systemapi - * @since 9 - */ + * Sets scale options of window. + * @param scaleOptions scale param of window. + * @systemapi + * @since 9 + */ setScaleSync(scaleOptions: ScaleOptions): void; /** - * Sets rotate options of window. - * @param rotateOptions rotate param of window. - * @systemapi - * @since 9 - */ + * Sets rotate options of window. + * @param rotateOptions rotate param of window. + * @systemapi + * @since 9 + */ setRotateSync(rotateOptions: RotateOptions): void; /** - * Sets whether is transparent or not. - * @param translateOptions translate param of window. - * @systemapi - * @since 9 - */ + * Sets whether is transparent or not. + * @param translateOptions translate param of window. + * @systemapi + * @since 9 + */ setTranslateSync(translateOptions: TranslateOptions): void; + /** + * Get Transition Controller. + * @systemapi + * @since 9 + */ + getTransitionControllerSync(): TransitionController; + } + /** + * Transition Context + * @syscap SystemCapability.WindowManager.WindowManager.Core + * @systempi + * @since 9 + */ + interface TransitionContext { + /** + * The target window with animation + */ + toWindow: Window + /** + * Set complete state of animation transition + * @param isCompleted is Completed if true, or not if false. + */ + completeTransition(isCompleted: boolean): void; + } + + /** + * Transition Controller + * @syscap SystemCapability.WindowManager.WindowManager.Core + * @systempi + * @since 9 + */ + interface TransitionController { + /** + * Animation configuration when showing window + * @param context transition Context. + */ + animationForShown(context: TransitionContext): void; + /** + * Animation configuration when hiding window + * @param context transition context. + */ + animationForHidden(context: TransitionContext): void; } enum WindowStageEventType { diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.cpp b/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.cpp new file mode 100644 index 0000000000..2975e167e7 --- /dev/null +++ b/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.cpp @@ -0,0 +1,250 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "js_transition_controller.h" +#include "js_runtime_utils.h" +#include "window.h" +#include "window_helper.h" +#include "window_manager_hilog.h" +#include "window_option.h" +namespace OHOS { +namespace Rosen { +using namespace AbilityRuntime; +namespace { + constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "JsTransitionController"}; +} + +static int jsTransCxtCtorCnt = 0; +static int jsTransCxtDtorCnt = 0; +static int jsTransCtrlCtorCnt = 0; +static int jsTransCtrlDtorCnt = 0; + +JsTransitionContext::JsTransitionContext(sptr window, bool isShownTransContext) + : windowToken_(window), isShownTransContext_(isShownTransContext) +{ + WLOGFI("[NAPI] JsTransitionContext constructorCnt: %{public}d", ++jsTransCxtCtorCnt); +} + +JsTransitionContext::~JsTransitionContext() +{ + WLOGFI("[NAPI] ~JsTransitionContext deConstructorCnt: %{public}d", ++jsTransCxtDtorCnt); +} + +void JsTransitionContext::Finalizer(NativeEngine* engine, void* data, void* hint) +{ + WLOGFI("[NAPI]JsTransitionContext::Finalizer"); + std::unique_ptr(static_cast(data)); +} + +NativeValue* JsTransitionContext::CompleteTransition(NativeEngine* engine, NativeCallbackInfo* info) +{ + WLOGFI("[NAPI]CompleteTransition"); + JsTransitionContext* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnCompleteTransition(*engine, *info) : nullptr; +} + +NativeValue* JsTransitionContext::OnCompleteTransition(NativeEngine& engine, NativeCallbackInfo& info) +{ + WLOGFI("[NAPI]OnCompleteTransition"); + WMError errCode = WMError::WM_OK; + if (info.argc < 1 || info.argc > 2) { // 2: maximum params + WLOGFE("[NAPI]Argc is invalid: %{public}zu", info.argc); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + bool transitionCompleted = false; + if (errCode == WMError::WM_OK && !ConvertFromJsValue(engine, info.argv[0], transitionCompleted)) { + WLOGFE("[NAPI]Failed to convert parameter to transitionCompleted"); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + AsyncTask::CompleteCallback complete = + [weakWindow = windowToken_, errCode, transitionCompleted, isShownTransContext = isShownTransContext_]( + NativeEngine& engine, AsyncTask& task, int32_t status) { + HandleScope handleScope(engine); + auto window = weakWindow.promote(); + if (window == nullptr || errCode != WMError::WM_OK) { + task.Reject(engine, CreateJsError(engine, static_cast(errCode))); + WLOGFE("[NAPI]window is nullptr or get invalid param"); + return; + } + WMError ret = WMError::WM_OK; + if (!isShownTransContext) { + window->UpdateSurfaceNodeAfterCustomAnimation(false); // remove from rs tree after animation + if (!transitionCompleted) { + ret = window->Show(); // hide success + } + } else { + if (!transitionCompleted) { + ret = window->Hide(); // hide success + } + } + if (ret != WMError::WM_OK) { + task.Reject(engine, CreateJsError(engine, static_cast(ret), "Window destroy failed")); + return; + } + WLOGFI("[NAPI]Window [%{public}u, %{public}s] CompleteTransition %{public}d end", + window->GetWindowId(), window->GetWindowName().c_str(), transitionCompleted); + task.Resolve(engine, engine.CreateUndefined()); + }; + + NativeValue* lastParam = (info.argc <= 1) ? nullptr : + (info.argv[1]->TypeOf() == NATIVE_FUNCTION ? info.argv[1] : nullptr); + NativeValue* result = nullptr; + AsyncTask::Schedule("JsTransitionContext::OnCompleteTransition", + engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + return result; +} + +static NativeValue* CreateJsTransitionContextObject(NativeEngine& engine, std::shared_ptr jsWin, + sptr window, bool isShownTransContext) +{ + WLOGFI("[NAPI]CreateJsTransitionContextObject"); + NativeValue *objValue = engine.CreateObject(); + NativeObject *object = ConvertNativeValueTo(objValue); + if (object == nullptr) { + WLOGFE("[NAPI]Failed to get object"); + return nullptr; + } + std::unique_ptr jsTransContext = std::make_unique(window, + isShownTransContext); + object->SetNativePointer(jsTransContext.release(), JsTransitionContext::Finalizer, nullptr); + if (jsWin != nullptr && jsWin->Get() != nullptr) { + object->SetProperty("toWindow", jsWin->Get()); + } else { + WLOGFE("[NAPI]jsWin is nullptr"); + return nullptr; + } + + BindNativeFunction(engine, *object, "completeTransition", JsTransitionContext::CompleteTransition); + return objValue; +} + +JsTransitionController::JsTransitionController(NativeEngine& engine, std::shared_ptr jsWin, + sptr window) + : engine_(engine), jsWin_(jsWin), windowToken_(window), weakRef_(wptr (this)) +{ + WLOGFI("[NAPI] JsTransitionController constructorCnt: %{public}d", ++jsTransCtrlCtorCnt); +} + +JsTransitionController::~JsTransitionController() +{ + WLOGFI("[NAPI] ~JsTransitionController deConstructorCnt: %{public}d", ++jsTransCtrlDtorCnt); +} + +void JsTransitionController::AnimationForShown() +{ + WLOGFI("[NAPI]AnimationForShown"); + std::unique_ptr complete = std::make_unique ( + [self = weakRef_](NativeEngine&, AsyncTask&, int32_t) { + auto thisController = self.promote(); + if (thisController == nullptr) { + WLOGFE("this transition Controller is null!"); + return; + } + HandleScope handleScope(thisController->engine_); + auto jsWin = thisController->jsWin_.lock(); + auto window = thisController->windowToken_.promote(); + if (jsWin == nullptr || window == nullptr) { + WLOGFE("native window or jsWindow is null!"); + return; + } + auto state = window->GetWindowState(); + if (state != WindowState::STATE_SHOWN) { + WLOGFE("animation shown configuration for state %{public}u not support!", static_cast(state)); + return; + } + NativeValue* jsTransContextObj = CreateJsTransitionContextObject( + thisController->engine_, jsWin, window, true); + if (jsTransContextObj == nullptr) { + return; + } + NativeValue *argv[] = { jsTransContextObj }; + thisController->CallJsMethod("animationForShown", argv, ArraySize(argv)); + // add to rs tree before animation + window->UpdateSurfaceNodeAfterCustomAnimation(true); + } + ); + + NativeReference* callback = nullptr; + std::unique_ptr execute = nullptr; + AsyncTask::Schedule("JsTransitionController::AnimationForShown", engine_, + std::make_unique(callback, std::move(execute), std::move(complete))); +} + +void JsTransitionController::AnimationForHidden() +{ + WLOGFI("[NAPI]AnimationForHidden"); + std::unique_ptr complete = std::make_unique ( + [self = weakRef_](NativeEngine&, AsyncTask&, int32_t) { + auto thisController = self.promote(); + if (thisController == nullptr) { + WLOGFE("this transition Controller is null!"); + return; + } + HandleScope handleScope(thisController->engine_); + auto jsWin = thisController->jsWin_.lock(); + auto window = thisController->windowToken_.promote(); + if (jsWin == nullptr || window == nullptr) { + WLOGFE("native window or jsWindow is null!"); + return; + } + auto state = window->GetWindowState(); + if (state != WindowState::STATE_HIDDEN) { + WLOGFE("animation hidden configuration for state %{public}u not support!", + static_cast(state)); + return; + } + NativeValue* jsTransContextObj = CreateJsTransitionContextObject( + thisController->engine_, jsWin, window, false); + if (jsTransContextObj == nullptr) { + return; + } + NativeValue *argv[] = { jsTransContextObj }; + thisController->CallJsMethod("animationForHidden", argv, ArraySize(argv)); + } + ); + NativeReference* callback = nullptr; + std::unique_ptr execute = nullptr; + AsyncTask::Schedule("JsTransitionController::AnimationForHidden", engine_, + std::make_unique(callback, std::move(execute), std::move(complete))); +} + +void JsTransitionController::CallJsMethod(const std::string& methodName, NativeValue* const* argv, size_t argc) +{ + WLOGFI("Call js function:%{public}s.", methodName.c_str()); + auto self = jsTransControllerObj_.lock(); + if (self == nullptr) { + WLOGFE("JsController is null!"); + return; + } + auto jsControllerValue = self->Get(); + auto jsControllerObj = ConvertNativeValueTo(jsControllerValue); + if (jsControllerObj == nullptr) { + WLOGFE("JsControllerObj is null!"); + return; + } + auto method = jsControllerObj->GetProperty(methodName.c_str()); + if (method == nullptr || method->TypeOf() == NATIVE_UNDEFINED) { + WLOGFE("Failed to get %{public}s from object", methodName.c_str()); + return; + } + engine_.CallFunction(jsControllerValue, method, argv, argc); +} + +void JsTransitionController::SetJsController(std::shared_ptr jsVal) +{ + jsTransControllerObj_ = jsVal; +} +} +} \ No newline at end of file diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.h b/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.h new file mode 100644 index 0000000000..d7a88c7b56 --- /dev/null +++ b/interfaces/kits/napi/window_runtime/window_napi/js_transition_controller.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_JS_TRANSITION_CONTROLLER_H +#define OHOS_JS_TRANSITION_CONTROLLER_H + +#include "native_engine/native_engine.h" +#include "native_engine/native_value.h" +#include "window.h" + +namespace OHOS { +namespace Rosen { +class JsTransitionContext { +public: + JsTransitionContext(sptr window, bool shownState); + ~JsTransitionContext(); + static void Finalizer(NativeEngine* engine, void* data, void* hint); + static NativeValue* CompleteTransition(NativeEngine* engine, NativeCallbackInfo* info); +private: + NativeValue* OnCompleteTransition(NativeEngine& engine, NativeCallbackInfo& info); + wptr windowToken_; + bool isShownTransContext_ = false; +}; + +class JsTransitionController : public IAnimationTransitionController { +public: + JsTransitionController(NativeEngine& engine, std::shared_ptr jsWin, sptr window); + ~JsTransitionController(); + void AnimationForShown() override; + void AnimationForHidden() override; + void SetJsController(std::shared_ptr jsVal); +private: + void CallJsMethod(const std::string& methodName, NativeValue* const* argv, size_t argc); + NativeEngine& engine_; + std::weak_ptr jsTransControllerObj_; + std::weak_ptr jsWin_; + wptr windowToken_; + wptr weakRef_ = nullptr; +}; +} +} +#endif \ No newline at end of file diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp b/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp index cb8148f0ed..1e5f41e7a6 100644 --- a/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp +++ b/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp @@ -16,6 +16,7 @@ #include "js_window.h" #include #include +#include "js_transition_controller.h" #include "js_window_utils.h" #include "window.h" #include "window_helper.h" @@ -47,12 +48,12 @@ JsWindow::JsWindow(const sptr& window) WLOGFI("[NAPI]Destroy window %{public}s in js window", windowName.c_str()); }; windowToken_->RegisterWindowDestroyedListener(func); - WLOGFI("[NAPI] JsWindow constructor Count: %{public}d", ++ctorCnt); + WLOGFI("[NAPI] JsWindow constructorCnt: %{public}d", ++ctorCnt); } JsWindow::~JsWindow() { - WLOGFI("[NAPI]~JsWindow deconstructor Count:%{public}d", ++dtorCnt); + WLOGFI("[NAPI]~JsWindow deConstructorCnt:%{public}d", ++dtorCnt); windowToken_ = nullptr; } @@ -66,7 +67,7 @@ std::string JsWindow::GetWindowName() void JsWindow::Finalizer(NativeEngine* engine, void* data, void* hint) { - WLOGFI("[NAPI]Finalizer Count:%{public}d", ++finalizerCnt); + WLOGFI("[NAPI]finalizerCnt:%{public}d", ++finalizerCnt); auto jsWin = std::unique_ptr(static_cast(data)); if (jsWin == nullptr) { WLOGFE("[NAPI]jsWin is nullptr"); @@ -88,6 +89,13 @@ NativeValue* JsWindow::Show(NativeEngine* engine, NativeCallbackInfo* info) return (me != nullptr) ? me->OnShow(*engine, *info) : nullptr; } +NativeValue* JsWindow::ShowWithAnimation(NativeEngine* engine, NativeCallbackInfo* info) +{ + WLOGFI("[NAPI]ShowWithAnimation"); + JsWindow* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnShowWithAnimation(*engine, *info) : nullptr; +} + NativeValue* JsWindow::Destroy(NativeEngine* engine, NativeCallbackInfo* info) { WLOGFI("[NAPI]Destroy"); @@ -102,6 +110,13 @@ NativeValue* JsWindow::Hide(NativeEngine* engine, NativeCallbackInfo* info) return (me != nullptr) ? me->OnHide(*engine, *info) : nullptr; } +NativeValue* JsWindow::HideWithAnimation(NativeEngine* engine, NativeCallbackInfo* info) +{ + WLOGFI("[NAPI]HideWithAnimation"); + JsWindow* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnHideWithAnimation(*engine, *info) : nullptr; +} + NativeValue* JsWindow::MoveTo(NativeEngine* engine, NativeCallbackInfo* info) { WLOGFI("[NAPI]MoveTo"); @@ -347,6 +362,13 @@ NativeValue* JsWindow::SetTranslateSync(NativeEngine* engine, NativeCallbackInfo return (me != nullptr) ? me->OnSetTranslateSync(*engine, *info) : nullptr; } +NativeValue* JsWindow::GetTransitionControllerSync(NativeEngine* engine, NativeCallbackInfo* info) +{ + WLOGFI("[NAPI]GetTransitionControllerSync"); + JsWindow* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnGetTransitionControllerSync(*engine, *info) : nullptr; +} + NativeValue* JsWindow::OnShow(NativeEngine& engine, NativeCallbackInfo& info) { WMError errCode = WMError::WM_OK; @@ -363,7 +385,7 @@ NativeValue* JsWindow::OnShow(NativeEngine& engine, NativeCallbackInfo& info) WLOGFE("[NAPI]window is nullptr or get invalid param"); return; } - WMError ret = weakWindow->Show(); + WMError ret = weakWindow->Show(0, false); if (ret == WMError::WM_OK) { task.Resolve(engine, engine.CreateUndefined()); } else { @@ -372,15 +394,52 @@ NativeValue* JsWindow::OnShow(NativeEngine& engine, NativeCallbackInfo& info) WLOGFI("[NAPI]Window [%{public}u, %{public}s] show end, ret = %{public}d", weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret); }; - + NativeValue* result = nullptr; NativeValue* lastParam = (info.argc == 0) ? nullptr : (info.argv[0]->TypeOf() == NATIVE_FUNCTION ? info.argv[0] : nullptr); - NativeValue* result = nullptr; AsyncTask::Schedule("JsWindow::OnShow", engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); return result; } +NativeValue* JsWindow::OnShowWithAnimation(NativeEngine& engine, NativeCallbackInfo& info) +{ + WMError errCode = WMError::WM_OK; + if (info.argc > 1) { + WLOGFE("[NAPI]Argc is invalid: %{public}zu", info.argc); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + auto winType = windowToken_->GetType(); + if (!WindowHelper::IsSystemWindow(winType)) { + WLOGFE("[NAPI]window Type %{public}u is not supported", static_cast(winType)); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + wptr weakToken(windowToken_); + AsyncTask::CompleteCallback complete = + [weakToken, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + auto weakWindow = weakToken.promote(); + if (weakWindow == nullptr || errCode != WMError::WM_OK) { + task.Reject(engine, CreateJsError(engine, static_cast(errCode))); + WLOGFE("[NAPI]window is nullptr or get invalid param"); + return; + } + WMError ret = weakWindow->Show(0, true); + if (ret == WMError::WM_OK) { + task.Resolve(engine, engine.CreateUndefined()); + } else { + task.Reject(engine, CreateJsError(engine, static_cast(ret), "Window show failed")); + } + WLOGFI("[NAPI]Window [%{public}u, %{public}s] ShowWithAnimation end, ret = %{public}d", + weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret); + }; + NativeValue* result = nullptr; + NativeValue* lastParam = (info.argc == 0) ? nullptr : + (info.argv[0]->TypeOf() == NATIVE_FUNCTION ? info.argv[0] : nullptr); + AsyncTask::Schedule("JsWindow::OnShowWithAnimation", + engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + return result; +} + NativeValue* JsWindow::OnDestroy(NativeEngine& engine, NativeCallbackInfo& info) { WMError errCode = WMError::WM_OK; @@ -432,7 +491,7 @@ NativeValue* JsWindow::OnHide(NativeEngine& engine, NativeCallbackInfo& info) WLOGFE("[NAPI]window is nullptr or get invalid param"); return; } - WMError ret = weakWindow->Hide(); + WMError ret = weakWindow->Hide(0, false); if (ret == WMError::WM_OK) { task.Resolve(engine, engine.CreateUndefined()); } else { @@ -442,14 +501,52 @@ NativeValue* JsWindow::OnHide(NativeEngine& engine, NativeCallbackInfo& info) weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret); }; + NativeValue* result = nullptr; NativeValue* lastParam = (info.argc == 0) ? nullptr : (info.argv[0]->TypeOf() == NATIVE_FUNCTION ? info.argv[0] : nullptr); - NativeValue* result = nullptr; AsyncTask::Schedule("JsWindow::OnHide", engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); return result; } +NativeValue* JsWindow::OnHideWithAnimation(NativeEngine& engine, NativeCallbackInfo& info) +{ + WMError errCode = WMError::WM_OK; + if (info.argc > 1) { + WLOGFE("[NAPI]Argc is invalid: %{public}zu", info.argc); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + auto winType = windowToken_->GetType(); + if (!WindowHelper::IsSystemWindow(winType)) { + WLOGFE("[NAPI]window Type %{public}u is not supported", static_cast(winType)); + errCode = WMError::WM_ERROR_INVALID_PARAM; + } + wptr weakToken(windowToken_); + AsyncTask::CompleteCallback complete = + [weakToken, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + auto weakWindow = weakToken.promote(); + if (weakWindow == nullptr || errCode != WMError::WM_OK) { + task.Reject(engine, CreateJsError(engine, static_cast(errCode))); + WLOGFE("[NAPI]window is nullptr or get invalid param"); + return; + } + WMError ret = weakWindow->Hide(0, true); + if (ret == WMError::WM_OK) { + task.Resolve(engine, engine.CreateUndefined()); + } else { + task.Reject(engine, CreateJsError(engine, static_cast(ret), "Window show failed")); + } + WLOGFI("[NAPI]Window [%{public}u, %{public}s] HideWithAnimation end, ret = %{public}d", + weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret); + }; + NativeValue* result = nullptr; + NativeValue* lastParam = (info.argc == 0) ? nullptr : + (info.argv[0]->TypeOf() == NATIVE_FUNCTION ? info.argv[0] : nullptr); + AsyncTask::Schedule("JsWindow::OnHideWithAnimation", + engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + return result; +} + NativeValue* JsWindow::OnMoveTo(NativeEngine& engine, NativeCallbackInfo& info) { WMError errCode = WMError::WM_OK; @@ -1053,7 +1150,7 @@ NativeValue* JsWindow::OnIsShowing(NativeEngine& engine, NativeCallbackInfo& inf WLOGFE("[NAPI]window is nullptr or get invalid param"); return; } - bool state = weakWindow->GetShowState(); + bool state = weakWindow->GetWindowState() == WindowState::STATE_SHOWN; task.Resolve(engine, CreateJsValue(engine, state)); WLOGFI("[NAPI]Window [%{public}u, %{public}s] get show state end, state = %{public}u", weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), state); @@ -1870,6 +1967,57 @@ NativeValue* JsWindow::OnSetTranslateSync(NativeEngine& engine, NativeCallbackIn return engine.CreateUndefined(); } +void JsWindow::CreateTransitionController(NativeEngine& engine) +{ + if (windowToken_ == nullptr) { + WLOGFE("[NAPI]windowToken_ is nullptr not match"); + return; + } + if (!WindowHelper::IsSystemWindow(windowToken_->GetType())) { + WLOGFE("[NAPI]CreateTransitionController is not allowed since window is not system window"); + return; + } + NativeValue* objValue = engine.CreateObject(); + auto name = GetWindowName(); + std::shared_ptr jsWindowObj = FindJsWindowObject(name); + if (jsWindowObj == nullptr || jsWindowObj->Get() == nullptr) { + return; + } + sptr nativeController = new JsTransitionController( + engine, jsWindowObj, windowToken_); + NativeObject* object = ConvertNativeValueTo(objValue); + if (object == nullptr) { + WLOGFE("[NAPI]Failed to convert to TransitionController Object"); + return; + } + object->SetNativePointer(new wptr(nativeController), + [](NativeEngine*, void* data, void*) { + WLOGFE("Finalizer for wptr form native Transition Controller is called"); + delete static_cast*>(data); + }, nullptr); + windowToken_->RegisterAnimationTransitionController(nativeController); + jsTransControllerObj_.reset(engine.CreateReference(objValue, 1)); + nativeController->SetJsController(jsTransControllerObj_); + WLOGFI("[NAPI]Window [%{public}u, %{public}s] CreateTransitionController end", + windowToken_->GetWindowId(), windowToken_->GetWindowName().c_str()); +} + +NativeValue* JsWindow::OnGetTransitionControllerSync(NativeEngine& engine, NativeCallbackInfo& info) +{ + if (windowToken_ == nullptr || info.argc > 0) { + WLOGFE("[NAPI]windowToken_ is nullptr or params %{public}zu not match", info.argc); + return engine.CreateUndefined(); + } + if (!WindowHelper::IsSystemWindow(windowToken_->GetType())) { + WLOGFE("[NAPI]OnCreateTransitionControllerSync is not allowed since window is not system window"); + return engine.CreateUndefined(); + } + if (jsTransControllerObj_ == nullptr || jsTransControllerObj_->Get() == nullptr) { + CreateTransitionController(engine); + } + return jsTransControllerObj_->Get(); +} + std::shared_ptr FindJsWindowObject(std::string windowName) { WLOGFI("[NAPI]Try to find window %{public}s in g_jsWindowMap", windowName.c_str()); @@ -1910,8 +2058,10 @@ NativeValue* CreateJsWindowObject(NativeEngine& engine, sptr& window) void BindFunctions(NativeEngine& engine, NativeObject* object) { BindNativeFunction(engine, *object, "show", JsWindow::Show); + BindNativeFunction(engine, *object, "showWithAnimation", JsWindow::ShowWithAnimation); BindNativeFunction(engine, *object, "destroy", JsWindow::Destroy); BindNativeFunction(engine, *object, "hide", JsWindow::Hide); + BindNativeFunction(engine, *object, "hideWithAnimation", JsWindow::HideWithAnimation); BindNativeFunction(engine, *object, "moveTo", JsWindow::MoveTo); BindNativeFunction(engine, *object, "resetSize", JsWindow::Resize); BindNativeFunction(engine, *object, "setWindowType", JsWindow::SetWindowType); @@ -1947,6 +2097,7 @@ void BindFunctions(NativeEngine& engine, NativeObject* object) BindNativeFunction(engine, *object, "setScaleSync", JsWindow::SetScaleSync); BindNativeFunction(engine, *object, "setRotateSync", JsWindow::SetRotateSync); BindNativeFunction(engine, *object, "setTranslateSync", JsWindow::SetTranslateSync); + BindNativeFunction(engine, *object, "getTransitionControllerSync", JsWindow::GetTransitionControllerSync); } } // namespace Rosen } // namespace OHOS diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window.h b/interfaces/kits/napi/window_runtime/window_napi/js_window.h index e6c2296fff..30a2b36fbc 100644 --- a/interfaces/kits/napi/window_runtime/window_napi/js_window.h +++ b/interfaces/kits/napi/window_runtime/window_napi/js_window.h @@ -34,8 +34,10 @@ public: ~JsWindow(); static void Finalizer(NativeEngine* engine, void* data, void* hint); static NativeValue* Show(NativeEngine* engine, NativeCallbackInfo* info); + static NativeValue* ShowWithAnimation(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* Destroy(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* Hide(NativeEngine* engine, NativeCallbackInfo* info); + static NativeValue* HideWithAnimation(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* MoveTo(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* Resize(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* SetWindowType(NativeEngine* engine, NativeCallbackInfo* info); @@ -74,14 +76,17 @@ public: static NativeValue* SetScaleSync(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* SetRotateSync(NativeEngine* engine, NativeCallbackInfo* info); static NativeValue* SetTranslateSync(NativeEngine* engine, NativeCallbackInfo* info); + static NativeValue* GetTransitionControllerSync(NativeEngine* engine, NativeCallbackInfo* info); private: std::string GetWindowName(); bool ParseScaleOption(NativeEngine& engine, NativeObject* jsObject, Transform& trans); bool ParseRotateOption(NativeEngine& engine, NativeObject* jsObject, Transform& trans); bool ParseTranslateOption(NativeEngine& engine, NativeObject* jsObject, Transform& trans); NativeValue* OnShow(NativeEngine& engine, NativeCallbackInfo& info); + NativeValue* OnShowWithAnimation(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnDestroy(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnHide(NativeEngine& engine, NativeCallbackInfo& info); + NativeValue* OnHideWithAnimation(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnMoveTo(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnResize(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnSetWindowType(NativeEngine& engine, NativeCallbackInfo& info); @@ -121,8 +126,12 @@ private: NativeValue* OnSetScaleSync(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnSetRotateSync(NativeEngine& engine, NativeCallbackInfo& info); NativeValue* OnSetTranslateSync(NativeEngine& engine, NativeCallbackInfo& info); + NativeValue* OnGetTransitionControllerSync(NativeEngine& engine, NativeCallbackInfo& info); + void CreateTransitionController(NativeEngine& engine); + sptr windowToken_ = nullptr; std::unique_ptr registerManager_ = nullptr; + std::shared_ptr jsTransControllerObj_ = nullptr; }; } // namespace Rosen } // namespace OHOS diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.cpp b/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.cpp index 00dd861473..497100cdfc 100644 --- a/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.cpp +++ b/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.cpp @@ -528,12 +528,12 @@ bool GetAPI7Ability(NativeEngine& engine, AppExecFwk::Ability* &ability) return true; } -bool ParseJsDoubleValue(NativeObject* jsObject, NativeEngine& engine, const std::string& name, double data) +bool ParseJsDoubleValue(NativeObject* jsObject, NativeEngine& engine, const std::string& name, double& data) { NativeValue* value = jsObject->GetProperty(name.c_str()); if (value->TypeOf() != NATIVE_UNDEFINED) { if (!ConvertFromJsValue(engine, value, data)) { - WLOGFE("[NAPI]Failed to convert parameter to scale %{public}s", name.c_str()); + WLOGFE("[NAPI]Failed to convert parameter to data: %{public}s", name.c_str()); return false; } } else { diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.h b/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.h index b8ba7106a1..9a2fabeb16 100644 --- a/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.h +++ b/interfaces/kits/napi/window_runtime/window_napi/js_window_utils.h @@ -166,7 +166,7 @@ const std::map JS_TO_NATIVE_ORIENTATION_MAP { NativeValue* WindowStageEventTypeInit(NativeEngine* engine); NativeValue* WindowLayoutModeInit(NativeEngine* engine); bool GetAPI7Ability(NativeEngine& engine, AppExecFwk::Ability* &ability); - bool ParseJsDoubleValue(NativeObject* jsObject, NativeEngine& engine, const std::string& name, double data); + bool ParseJsDoubleValue(NativeObject* jsObject, NativeEngine& engine, const std::string& name, double& data); template inline bool ConvertNativeValueToVector(NativeEngine& engine, NativeValue* nativeValue, std::vector& out) { diff --git a/interfaces/kits/napi/window_runtime/window_stage_napi/js_window_stage.cpp b/interfaces/kits/napi/window_runtime/window_stage_napi/js_window_stage.cpp index 929a313fa0..c28612a5a6 100644 --- a/interfaces/kits/napi/window_runtime/window_stage_napi/js_window_stage.cpp +++ b/interfaces/kits/napi/window_runtime/window_stage_napi/js_window_stage.cpp @@ -37,6 +37,7 @@ JsWindowStage::JsWindowStage(const std::shared_ptr& windowSc JsWindowStage::~JsWindowStage() { } + void JsWindowStage::Finalizer(NativeEngine* engine, void* data, void* hint) { WLOGFI("[NAPI]Finalizer"); diff --git a/utils/include/wm_common_inner.h b/utils/include/wm_common_inner.h index 808f408367..712f4f4866 100644 --- a/utils/include/wm_common_inner.h +++ b/utils/include/wm_common_inner.h @@ -29,17 +29,6 @@ enum class LifeCycleEvent : uint32_t { DESTROY_EVENT, }; -enum class WindowState : uint32_t { - STATE_INITIAL, - STATE_CREATED, - STATE_SHOWN, - STATE_HIDDEN, - STATE_FROZEN, - STATE_DESTROYED, - STATE_BOTTOM = STATE_DESTROYED, - STATE_UNFROZEN, -}; - enum class WindowStateChangeReason : uint32_t { NORMAL, KEYGUARD, diff --git a/wm/include/window_impl.h b/wm/include/window_impl.h index a17d05a6e1..a089d0ddcd 100644 --- a/wm/include/window_impl.h +++ b/wm/include/window_impl.h @@ -108,7 +108,7 @@ public: virtual WindowMode GetMode() const override; virtual WindowBlurLevel GetWindowBackgroundBlur() const override; virtual float GetAlpha() const override; - virtual bool GetShowState() const override; + virtual WindowState GetWindowState() const override; virtual WMError SetFocusable(bool isFocusable) override; virtual bool GetFocusable() const override; virtual WMError SetTouchable(bool isTouchable) override; diff --git a/wm/src/window_impl.cpp b/wm/src/window_impl.cpp index 72ad62d18d..909b0f8d6f 100755 --- a/wm/src/window_impl.cpp +++ b/wm/src/window_impl.cpp @@ -225,9 +225,9 @@ float WindowImpl::GetAlpha() const return property_->GetAlpha(); } -bool WindowImpl::GetShowState() const +WindowState WindowImpl::GetWindowState() const { - return state_ == WindowState::STATE_SHOWN; + return state_; } WMError WindowImpl::SetFocusable(bool isFocusable) @@ -960,28 +960,10 @@ WMError WindowImpl::UpdateSurfaceNodeAfterCustomAnimation(bool isAdd) WMError WindowImpl::PreProcessShow(uint32_t reason, bool withAnimation) { - WindowStateChangeReason stateChangeReason = static_cast(reason); - if (stateChangeReason == WindowStateChangeReason::KEYGUARD || - stateChangeReason == WindowStateChangeReason::TOGGLING) { - state_ = WindowState::STATE_SHOWN; - NotifyAfterForeground(); - return WMError::WM_OK; - } if (state_ == WindowState::STATE_FROZEN) { WLOGFE("window is frozen, can not be shown, windowId: %{public}u", property_->GetWindowId()); return WMError::WM_ERROR_INVALID_OPERATION; } - if (state_ == WindowState::STATE_SHOWN) { - if (property_->GetWindowType() == WindowType::WINDOW_TYPE_DESKTOP) { - WLOGFI("desktop window [id:%{public}u] is shown, minimize all app windows", property_->GetWindowId()); - SingletonContainer::Get().MinimizeAllAppWindows(property_->GetDisplayId()); - } else { - WLOGFI("window is already shown id: %{public}u, raise to top", property_->GetWindowId()); - SingletonContainer::Get().ProcessPointDown(property_->GetWindowId()); - } - CALL_LIFECYCLE_LISTENER(AfterForeground); - return WMError::WM_OK; - } SetDefaultOption(); AdjustWindowAnimationFlag(withAnimation); // show failed when current mode is not support or window only supports split mode and can show when locked @@ -1005,7 +987,24 @@ WMError WindowImpl::Show(uint32_t reason, bool withAnimation) if (!IsWindowValid()) { return WMError::WM_ERROR_INVALID_WINDOW; } - + WindowStateChangeReason stateChangeReason = static_cast(reason); + if (stateChangeReason == WindowStateChangeReason::KEYGUARD || + stateChangeReason == WindowStateChangeReason::TOGGLING) { + state_ = WindowState::STATE_SHOWN; + NotifyAfterForeground(); + return WMError::WM_OK; + } + if (state_ == WindowState::STATE_SHOWN) { + if (property_->GetWindowType() == WindowType::WINDOW_TYPE_DESKTOP) { + WLOGFI("desktop window [id:%{public}u] is shown, minimize all app windows", property_->GetWindowId()); + SingletonContainer::Get().MinimizeAllAppWindows(property_->GetDisplayId()); + } else { + WLOGFI("window is already shown id: %{public}u, raise to top", property_->GetWindowId()); + SingletonContainer::Get().ProcessPointDown(property_->GetWindowId()); + } + CALL_LIFECYCLE_LISTENER(AfterForeground); + return WMError::WM_OK; + } WMError ret = PreProcessShow(reason, withAnimation); if (ret != WMError::WM_OK) { return ret; diff --git a/wm/test/systemtest/window_app_floating_window_test.cpp b/wm/test/systemtest/window_app_floating_window_test.cpp index 6f42ece032..e074c72182 100644 --- a/wm/test/systemtest/window_app_floating_window_test.cpp +++ b/wm/test/systemtest/window_app_floating_window_test.cpp @@ -153,8 +153,8 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow02, Function | MediumTest ASSERT_EQ(WMError::WM_OK, fltWin->Show()); ASSERT_EQ(WMError::WM_OK, scene->GoBackground()); - ASSERT_EQ(false, scene->GetMainWindow()->GetShowState()); - ASSERT_EQ(true, fltWin->GetShowState()); + ASSERT_EQ(false, scene->GetMainWindow()->GetWindowState() == WindowState::STATE_SHOWN); + ASSERT_EQ(true, fltWin->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, fltWin->Hide()); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); @@ -179,8 +179,8 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow03, Function | MediumTest ASSERT_EQ(WMError::WM_OK, fltWin->Show()); ASSERT_EQ(WMError::WM_OK, fltWin->Hide()); - ASSERT_EQ(false, fltWin->GetShowState()); - ASSERT_EQ(true, scene->GetMainWindow()->GetShowState()); + ASSERT_EQ(false, fltWin->GetWindowState() == WindowState::STATE_SHOWN); + ASSERT_EQ(true, scene->GetMainWindow()->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, scene->GoBackground()); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); @@ -206,7 +206,7 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow04, Function | MediumTest ASSERT_EQ(WMError::WM_OK, scene->GoDestroy()); ASSERT_EQ(nullptr, scene->GetMainWindow()); - ASSERT_EQ(false, fltWin->GetShowState()); + ASSERT_EQ(false, fltWin->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); } @@ -252,8 +252,8 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow06, Function | MediumTest ASSERT_EQ(WMError::WM_OK, fltWin->Show()); ASSERT_EQ(WMError::WM_OK, scene->GoBackground()); - ASSERT_EQ(false, scene->GetMainWindow()->GetShowState()); - ASSERT_EQ(true, fltWin->GetShowState()); + ASSERT_EQ(false, scene->GetMainWindow()->GetWindowState() == WindowState::STATE_SHOWN); + ASSERT_EQ(true, fltWin->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, fltWin->Hide()); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); @@ -278,8 +278,8 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow07, Function | MediumTest ASSERT_EQ(WMError::WM_OK, fltWin->Show()); ASSERT_EQ(WMError::WM_OK, fltWin->Hide()); - ASSERT_EQ(false, fltWin->GetShowState()); - ASSERT_EQ(true, scene->GetMainWindow()->GetShowState()); + ASSERT_EQ(false, fltWin->GetWindowState() == WindowState::STATE_SHOWN); + ASSERT_EQ(true, scene->GetMainWindow()->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, scene->GoBackground()); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); @@ -305,7 +305,7 @@ HWTEST_F(WindowAppFloatingWindowTest, AppFloatingWindow08, Function | MediumTest ASSERT_EQ(WMError::WM_OK, scene->GoDestroy()); ASSERT_EQ(nullptr, scene->GetMainWindow()); - ASSERT_EQ(false, fltWin->GetShowState()); + ASSERT_EQ(false, fltWin->GetWindowState() == WindowState::STATE_SHOWN); ASSERT_EQ(WMError::WM_OK, fltWin->Destroy()); } diff --git a/wm/test/unittest/window_impl_test.cpp b/wm/test/unittest/window_impl_test.cpp index a62f82601c..4f1967e5e6 100644 --- a/wm/test/unittest/window_impl_test.cpp +++ b/wm/test/unittest/window_impl_test.cpp @@ -755,10 +755,10 @@ HWTEST_F(WindowImplTest, Minimize01, Function | SmallTest | Level3) window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); window->Show(); - ASSERT_TRUE(window->GetShowState()); + ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); window->Minimize(); - ASSERT_FALSE(window->GetShowState()); + ASSERT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN)); EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); ASSERT_EQ(WMError::WM_OK, window->Destroy()); } @@ -780,9 +780,9 @@ HWTEST_F(WindowImplTest, Minimize02, Function | SmallTest | Level3) window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW); window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); window->Show(); - ASSERT_TRUE(window->GetShowState()); + ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); window->Minimize(); - ASSERT_TRUE(window->GetShowState()); + ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN)); EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK)); ASSERT_EQ(WMError::WM_OK, window->Destroy()); } @@ -868,7 +868,7 @@ HWTEST_F(WindowImplTest, MoveTo01, Function | SmallTest | Level3) EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); ASSERT_EQ(WMError::WM_OK, window->Create("")); ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode()); - ASSERT_FALSE(window->GetShowState()); + ASSERT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN)); const float moveRatio = 0.5; Rect newRect = {winRect.posX_ * moveRatio, winRect.posY_ * moveRatio, winRect.width_, winRect.height_}; window->MoveTo(newRect.posX_, newRect.posY_); @@ -895,7 +895,7 @@ HWTEST_F(WindowImplTest, Resize01, Function | SmallTest | Level3) EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK)); ASSERT_EQ(WMError::WM_OK, window->Create("")); ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode()); - ASSERT_FALSE(window->GetShowState()); + ASSERT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN)); const float resizeRatio = 0.5; Rect newRect = {winRect.posX_, winRect.posY_, winRect.width_ * resizeRatio, winRect.height_ * resizeRatio}; window->Resize(newRect.width_, newRect.height_); diff --git a/wmserver/src/zidl/window_manager_proxy.cpp b/wmserver/src/zidl/window_manager_proxy.cpp index b1c0fe0049..6aee548327 100644 --- a/wmserver/src/zidl/window_manager_proxy.cpp +++ b/wmserver/src/zidl/window_manager_proxy.cpp @@ -654,7 +654,7 @@ WMError WindowManagerProxy::UpdateRsTree(uint32_t windowId, bool isAdd) { MessageParcel data; MessageParcel reply; - MessageOption option; + MessageOption option(MessageOption::TF_ASYNC); if (!data.WriteInterfaceToken(GetDescriptor())) { WLOGFE("WriteInterfaceToken failed"); -- Gitee