1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_STAGE_PAGE_PATTERN_H 17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_STAGE_PAGE_PATTERN_H 18 19 #include <functional> 20 21 #include "base/memory/referenced.h" 22 #include "base/utils/noncopyable.h" 23 #include "core/animation/animator_info.h" 24 #include "core/animation/page_transition_common.h" 25 #include "core/common/autofill/auto_fill_trigger_state_holder.h" 26 #include "core/components/theme/app_theme.h" 27 #include "core/components_ng/pattern/stage/content_root_pattern.h" 28 #include "core/components_ng/pattern/stage/page_event_hub.h" 29 #include "core/components_ng/pattern/stage/page_info.h" 30 #include "core/components_ng/pattern/stage/page_transition_effect.h" 31 #include "core/pipeline_ng/pipeline_context.h" 32 33 namespace OHOS::Ace::NG { 34 35 using SharedTransitionMap = std::unordered_map<ShareId, WeakPtr<FrameNode>>; 36 using JSAnimatorMap = std::unordered_map<std::string, RefPtr<Framework::AnimatorInfo>>; 37 38 using DynamicPageSizeCallback = std::function<void(const SizeF& size)>; 39 /** 40 * When the page triggers 'onHide' or 'onShow', the callback is called, 41 * and the input parameter is 'true' for onHide and false for onShow. 42 */ 43 using PageVisibilityChangeCallback = std::function<void(bool)>; 44 using OnNewParamCallback = std::function<void(const std::string&)>; 45 46 enum class RouterPageState { 47 ABOUT_TO_APPEAR = 0, 48 ABOUT_TO_DISAPPEAR = 1, 49 ON_PAGE_SHOW = 2, 50 ON_PAGE_HIDE = 3, 51 ON_BACK_PRESS = 4, 52 }; 53 54 // PagePattern is the base class for page root render node. 55 class ACE_FORCE_EXPORT PagePattern : public ContentRootPattern, public FocusView, public AutoFillTriggerStateHolder { 56 DECLARE_ACE_TYPE(PagePattern, ContentRootPattern, FocusView, AutoFillTriggerStateHolder); 57 58 public: PagePattern(const RefPtr<PageInfo> & pageInfo)59 explicit PagePattern(const RefPtr<PageInfo>& pageInfo) : pageInfo_(pageInfo) {} 60 ~PagePattern() override = default; 61 IsMeasureBoundary()62 bool IsMeasureBoundary() const override 63 { 64 return true; 65 } 66 67 // For ArkTS1.2 SetOnNodeDisposeCallback(std::function<void ()> && disposeCallback)68 void SetOnNodeDisposeCallback(std::function<void()>&& disposeCallback) 69 { 70 disposeCallback_ = std::move(disposeCallback); 71 } 72 FireOnNodeDisposeCallback()73 void FireOnNodeDisposeCallback() 74 { 75 CHECK_NULL_VOID(disposeCallback_); 76 disposeCallback_(); 77 } 78 IsAtomicNode()79 bool IsAtomicNode() const override 80 { 81 return false; 82 } 83 IsEnableChildrenMatchParent()84 bool IsEnableChildrenMatchParent() override 85 { 86 return true; 87 } 88 GetPageInfo()89 const RefPtr<PageInfo>& GetPageInfo() const 90 { 91 return pageInfo_; 92 } 93 GetPageUrl()94 std::string GetPageUrl() const 95 { 96 return pageInfo_ ? pageInfo_->GetPageUrl() : ""; 97 } 98 99 virtual void OnShow(bool isFromWindow = false); 100 101 virtual void OnHide(bool isFromWindow = false); 102 103 bool OnBackPressed(); 104 GetPageState()105 RouterPageState GetPageState() const 106 { 107 return state_; 108 } 109 SetOnPageShow(std::function<void ()> && onPageShow)110 void SetOnPageShow(std::function<void()>&& onPageShow) 111 { 112 onPageShow_ = std::move(onPageShow); 113 } 114 SetOnPageHide(std::function<void ()> && onPageHide)115 void SetOnPageHide(std::function<void()>&& onPageHide) 116 { 117 onPageHide_ = std::move(onPageHide); 118 } 119 SetOnBackPressed(std::function<bool ()> && OnBackPressed)120 void SetOnBackPressed(std::function<bool()>&& OnBackPressed) 121 { 122 onBackPressed_ = std::move(OnBackPressed); 123 } 124 SetOnNewParam(OnNewParamCallback && onNewParam)125 void SetOnNewParam(OnNewParamCallback&& onNewParam) 126 { 127 onNewParam_ = std::move(onNewParam); 128 } 129 SetPageTransitionFunc(std::function<void ()> && pageTransitionFunc)130 void SetPageTransitionFunc(std::function<void()>&& pageTransitionFunc) 131 { 132 pageTransitionFunc_ = std::move(pageTransitionFunc); 133 } 134 RegisterDumpInfoListener(const std::function<void (const std::vector<std::string> &)> && callback)135 void RegisterDumpInfoListener(const std::function<void(const std::vector<std::string>&)>&& callback) 136 { 137 dumpListener_ = std::move(callback); 138 } 139 FireDumpListener(const std::vector<std::string> & params)140 void FireDumpListener(const std::vector<std::string>& params) 141 { 142 CHECK_NULL_VOID(dumpListener_); 143 auto dumpListener = dumpListener_; 144 dumpListener(params); 145 } 146 147 // find pageTransition effect according to transition type 148 RefPtr<PageTransitionEffect> FindPageTransitionEffect(PageTransitionType type); 149 150 void ClearPageTransitionEffect(); 151 152 RefPtr<PageTransitionEffect> GetTopTransition() const; 153 154 void AddPageTransition(const RefPtr<PageTransitionEffect>& effect); 155 CreateEventHub()156 RefPtr<EventHub> CreateEventHub() override 157 { 158 return MakeRefPtr<PageEventHub>(); 159 } 160 GetFocusPattern()161 FocusPattern GetFocusPattern() const override 162 { 163 return { FocusType::SCOPE, true }; 164 } 165 GetRouteOfFirstScope()166 std::list<int32_t> GetRouteOfFirstScope() override 167 { 168 return { 0 }; 169 } 170 171 ScopeFocusAlgorithm GetScopeFocusAlgorithm() override; 172 WeakPtr<FocusHub> GetNextFocusNode(FocusStep step, const WeakPtr<FocusHub>& currentFocusNode); 173 GetSharedTransitionMap()174 const SharedTransitionMap& GetSharedTransitionMap() const 175 { 176 return sharedTransitionMap_; 177 } 178 179 void AddJsAnimator(const std::string& animatorId, const RefPtr<Framework::AnimatorInfo>& animatorInfo); 180 RefPtr<Framework::AnimatorInfo> GetJsAnimator(const std::string& animatorId); 181 182 void BuildSharedTransitionMap(); 183 184 void ReloadPage(); 185 186 void SetFirstBuildCallback(std::function<void()>&& buildCallback); 187 SetPageInTransition(bool pageTransition)188 void SetPageInTransition(bool pageTransition) 189 { 190 isPageInTransition_ = pageTransition; 191 } 192 GetPageInTransition()193 bool GetPageInTransition() const 194 { 195 return isPageInTransition_; 196 } 197 198 // Mark current page node invisible in render tree. 199 void ProcessHideState(); 200 // Mark current page node visible in render tree. 201 void ProcessShowState(); 202 203 bool ProcessAutoSave(const std::function<void()>& onFinish = nullptr, 204 const std::function<void()>& onUIExtNodeBindingCompleted = nullptr); 205 MarkRenderDone()206 void MarkRenderDone() 207 { 208 isRenderDone_ = true; 209 } 210 211 void StopPageTransition(); 212 SetDynamicPageSizeCallback(DynamicPageSizeCallback && dynamicPageSizeCallback)213 void SetDynamicPageSizeCallback(DynamicPageSizeCallback&& dynamicPageSizeCallback) 214 { 215 dynamicPageSizeCallback_ = std::move(dynamicPageSizeCallback); 216 } 217 AddOnHiddenChange(int32_t id,PageVisibilityChangeCallback && onHiddenChange)218 void AddOnHiddenChange(int32_t id, PageVisibilityChangeCallback&& onHiddenChange) 219 { 220 onHiddenChange_[id] = std::move(onHiddenChange); 221 } 222 FireOnHiddenChange(bool flag)223 void FireOnHiddenChange(bool flag) 224 { 225 for (auto& onHiddenChangeInfo : onHiddenChange_) { 226 if (onHiddenChangeInfo.second) { 227 auto onHiddenChange = onHiddenChangeInfo.second; 228 onHiddenChange(flag); 229 } 230 } 231 } 232 UpdatePageParam()233 void UpdatePageParam() 234 { 235 auto host = GetHost(); 236 CHECK_NULL_VOID(host); 237 host->SetAccessibilityVisible(true); 238 host->SetJSViewActive(true); 239 } 240 RemoveOnHiddenChange(int32_t id)241 void RemoveOnHiddenChange(int32_t id) 242 { 243 auto iter = onHiddenChange_.find(id); 244 if (iter != onHiddenChange_.end()) { 245 onHiddenChange_.erase(iter); 246 } 247 } 248 CreateOverlayManager(bool isShow)249 void CreateOverlayManager(bool isShow) 250 { 251 if (!overlayManager_ && isShow) { 252 overlayManager_ = MakeRefPtr<OverlayManager>(GetHost()); 253 } 254 } 255 GetOverlayManager()256 const RefPtr<OverlayManager>& GetOverlayManager() 257 { 258 return overlayManager_; 259 } 260 DeleteOverlayManager()261 void DeleteOverlayManager() 262 { 263 overlayManager_.Reset(); 264 } 265 266 bool RemoveOverlay(); 267 void MarkDirtyOverlay(); 268 IsOnShow()269 bool IsOnShow() 270 { 271 return isOnShow_; 272 } 273 GetIsModalCovered()274 bool GetIsModalCovered() const 275 { 276 return isModalCovered_; 277 } 278 SetIsModalCovered(bool isModalCovered)279 void SetIsModalCovered(bool isModalCovered) 280 { 281 isModalCovered_ = isModalCovered; 282 } 283 SetPageVisibilityChangeCallback(PageVisibilityChangeCallback && callback)284 void SetPageVisibilityChangeCallback(PageVisibilityChangeCallback&& callback) 285 { 286 visibilityChangeCallback_ = std::move(callback); 287 } 288 SetAnimationId(int32_t animationId)289 void SetAnimationId(int32_t animationId) 290 { 291 animationId_ = animationId; 292 } 293 GetAnimationId()294 int32_t GetAnimationId() const 295 { 296 return animationId_; 297 } 298 299 void InitTransitionIn(const RefPtr<PageTransitionEffect>& effect, PageTransitionType type); 300 301 void InitTransitionOut(const RefPtr<PageTransitionEffect>& effect, PageTransitionType type); 302 303 void TransitionInFinish(const RefPtr<PageTransitionEffect>& effect, PageTransitionType type); 304 305 void TransitionOutFinish(const RefPtr<PageTransitionEffect>& effect, PageTransitionType type); 306 307 void FinishOutPage(const int32_t animationId, PageTransitionType type); 308 309 void FinishInPage(const int32_t animationId, PageTransitionType type); 310 311 RefPtr<PageTransitionEffect> GetDefaultPageTransition(PageTransitionType type); 312 313 void ResetPageTransitionEffect(); 314 315 void TriggerPageTransition(const std::function<void()>& onFinish, PageTransitionType type); 316 317 void OnDetachFromFrameNode(FrameNode* frameNode) override; 318 319 void OnWindowSizeChanged(int32_t width, int32_t height, WindowSizeChangeReason type) override; 320 SetIsNeedRemove(bool isNeedRemove)321 void SetIsNeedRemove(bool isNeedRemove) 322 { 323 isNeedRemove_ = isNeedRemove; 324 } 325 void CheckIsNeedForceExitWindow(bool result); 326 void RemoveJsChildImmediately(const RefPtr<FrameNode>& page, PageTransitionType transactionType); CheckEnableCustomNodeDel()327 bool CheckEnableCustomNodeDel() const { 328 return false; 329 } 330 331 bool IsNeedCallbackBackPressed(); 332 FireOnNewParam(const std::string & param)333 void FireOnNewParam(const std::string& param) 334 { 335 if (onNewParam_) { 336 onNewParam_(param); 337 } 338 } 339 340 protected: 341 void OnAttachToFrameNode() override; 342 void BeforeCreateLayoutWrapper() override; 343 bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& wrapper, const DirtySwapConfig& config) override; 344 void BeforeSyncGeometryProperties(const DirtySwapConfig& config) override; 345 void FirePageTransitionFinish(); 346 347 void OnAttachToMainTree() override; 348 void OnDetachFromMainTree() override; 349 350 bool AvoidKeyboard() const override; AvoidTop()351 bool AvoidTop() const override 352 { 353 return true; 354 } AvoidBottom()355 bool AvoidBottom() const override 356 { 357 return true; 358 } 359 AvoidCutout()360 bool AvoidCutout() const override 361 { 362 return true; 363 } 364 365 void NotifyPerfMonitorPageMsg(const std::string& pageUrl, const std::string& bundleName); 366 367 RefPtr<PageTransitionEffect> GetPageTransitionEffect(const RefPtr<PageTransitionEffect>& transition); 368 369 void SlideTransitionEffect(const SlideEffect& effect, const RectF& rect, TranslateOptions& translate); 370 371 void UpdateDefaultEnterPopEffect(RefPtr<PageTransitionEffect>& effect, float statusHeight); 372 373 void UpdateEnterPushEffect(RefPtr<PageTransitionEffect>& effect, float statusHeight); 374 375 void UpdateExitPushEffect(RefPtr<PageTransitionEffect>& effect, float statusHeight); 376 377 void UpdateAnimationOption(const RefPtr<PageTransitionEffect>& transition, 378 RefPtr<PageTransitionEffect>& effect, AnimationOption& option, PageTransitionType type); 379 380 virtual void TriggerDefaultTransition(const std::function<void()>& onFinish, PageTransitionType type); 381 382 void MaskAnimation(const Color& initialBackgroundColor, const Color& backgroundColor); 383 384 void NotifyNavigationLifecycle(bool isShow, bool isFromWindow); 385 386 void RecordPageEvent(bool isShow); 387 388 RefPtr<PageInfo> pageInfo_; 389 RefPtr<OverlayManager> overlayManager_; 390 391 OnNewParamCallback onNewParam_; 392 std::function<void()> disposeCallback_; 393 std::function<void()> onPageShow_; 394 std::function<void()> onPageHide_; 395 std::function<bool()> onBackPressed_; 396 std::function<void()> pageTransitionFunc_; 397 std::function<void()> firstBuildCallback_; 398 std::unordered_map<int32_t, PageVisibilityChangeCallback> onHiddenChange_; 399 DynamicPageSizeCallback dynamicPageSizeCallback_; 400 PageVisibilityChangeCallback visibilityChangeCallback_; 401 std::shared_ptr<std::function<void()>> pageTransitionFinish_; 402 std::list<RefPtr<PageTransitionEffect>> pageTransitionEffects_; 403 std::function<void(const std::vector<std::string>&)> dumpListener_; 404 405 int32_t animationId_ = -1; 406 bool isOnShow_ = false; 407 bool isFirstLoad_ = true; 408 bool isPageInTransition_ = false; 409 bool isRenderDone_ = false; 410 bool isModalCovered_ = false; 411 bool isNeedRemove_ = false; 412 413 #if defined(ENABLE_SPLIT_MODE) 414 bool needFireObserver_ = true; 415 #endif 416 417 SharedTransitionMap sharedTransitionMap_; 418 JSAnimatorMap jsAnimatorMap_; 419 RouterPageState state_ = RouterPageState::ABOUT_TO_APPEAR; 420 std::shared_ptr<AnimationUtils::Animation> currCustomAnimation_; 421 422 ACE_DISALLOW_COPY_AND_MOVE(PagePattern); 423 }; 424 } // namespace OHOS::Ace::NG 425 426 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_STAGE_PAGE_PATTERN_H 427