• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 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_OVERLAY_OVERLAY_MANAGER_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_OVERLAY_OVERLAY_MANAGER_H
18 
19 #include <cstdint>
20 #include <functional>
21 #include <stack>
22 #include <unordered_map>
23 #include <utility>
24 
25 #include "base/memory/ace_type.h"
26 #include "base/memory/referenced.h"
27 #include "base/utils/noncopyable.h"
28 #include "core/components/common/properties/placement.h"
29 #include "core/components/dialog/dialog_properties.h"
30 #include "core/components/picker/picker_data.h"
31 #include "core/components_ng/animation/geometry_transition.h"
32 #include "core/components_ng/base/ui_node.h"
33 #include "core/components_ng/pattern/calendar_picker/calendar_type_define.h"
34 #include "core/components_ng/pattern/overlay/modal_style.h"
35 #include "core/components_ng/pattern/overlay/sheet_style.h"
36 #include "core/components_ng/pattern/picker/datepicker_event_hub.h"
37 #include "core/components_ng/pattern/picker/picker_type_define.h"
38 #include "core/components_ng/pattern/text_picker/textpicker_event_hub.h"
39 #include "core/components_ng/pattern/toast/toast_layout_property.h"
40 #include "core/components_ng/pattern/toast/toast_view.h"
41 #include "core/pipeline_ng/ui_task_scheduler.h"
42 
43 namespace OHOS::Ace {
44 struct ModalUIExtensionCallbacks;
45 } // namespace OHOS::Ace
46 
47 namespace OHOS::AAFwk {
48 class Want;
49 } // namespace OHOS::AAFwk
50 
51 namespace OHOS::Ace::NG {
52 
53 struct PopupInfo {
54     int32_t popupId = -1;
55     WeakPtr<FrameNode> target;
56     RefPtr<FrameNode> popupNode;
57     bool markNeedUpdate = false;
58     bool isCurrentOnShow = false;
59     bool isBlockEvent = true;
60     SizeF targetSize;
61     OffsetF targetOffset;
62     bool focusable = false;
63 };
64 
65 // StageManager is the base class for root render node to perform page switch.
66 class ACE_EXPORT OverlayManager : public virtual AceType {
67     DECLARE_ACE_TYPE(OverlayManager, AceType);
68 
69 public:
OverlayManager(const RefPtr<FrameNode> & rootNode)70     explicit OverlayManager(const RefPtr<FrameNode>& rootNode) : rootNodeWeak_(rootNode) {}
~OverlayManager()71     ~OverlayManager() override
72     {
73         popupMap_.clear();
74     }
75     void ShowIndexerPopup(int32_t targetId, RefPtr<FrameNode>& customNode);
76     void RemoveIndexerPopupById(int32_t targetId);
77     void RemoveIndexerPopup();
78     void HidePopup(int32_t targetId, const PopupInfo& popupInfo);
79     RefPtr<FrameNode> HidePopupWithoutAnimation(int32_t targetId, const PopupInfo& popupInfo);
80     void ShowPopup(int32_t targetId, const PopupInfo& popupInfo);
81     void ErasePopup(int32_t targetId);
82     void HideAllPopups();
83     void HideCustomPopups();
84 
GetPopupInfo(int32_t targetId)85     PopupInfo GetPopupInfo(int32_t targetId) const
86     {
87         auto it = popupMap_.find(targetId);
88         if (it == popupMap_.end()) {
89             return {};
90         }
91         return it->second;
92     }
93 
HasPopupInfo(int32_t targetId)94     bool HasPopupInfo(int32_t targetId) const
95     {
96         return popupMap_.find(targetId) != popupMap_.end();
97     }
98 
ErasePopupInfo(int32_t targetId)99     void ErasePopupInfo(int32_t targetId)
100     {
101         if (popupMap_.find(targetId) != popupMap_.end()) {
102             popupMap_.erase(targetId);
103         }
104     }
105 
106     void ShowMenu(int32_t targetId, const NG::OffsetF& offset, RefPtr<FrameNode> menu = nullptr);
107     void HideMenu(const RefPtr<FrameNode>& menu, int32_t targetId, bool isMenuOnTouch = false);
108     void DeleteMenu(int32_t targetId);
109     void ShowMenuInSubWindow(int32_t targetId, const NG::OffsetF& offset, RefPtr<FrameNode> menu = nullptr);
110     void HideMenuInSubWindow(const RefPtr<FrameNode>& menu, int32_t targetId);
111     RefPtr<FrameNode> GetMenuNode(int32_t targetId);
112     void HideMenuInSubWindow(bool showPreviewAnimation = true, bool startDrag = false);
113     void CleanMenuInSubWindow();
114     void CleanPreviewInSubWindow();
115     void CleanPopupInSubWindow();
116     void CleanMenuInSubWindowWithAnimation();
117     void HideAllMenus();
118 
119     void ClearToastInSubwindow();
120     void ClearToast();
121     void ShowToast(const std::string& message, int32_t duration, const std::string& bottom, bool isRightToLeft,
122         const ToastShowMode& showMode = ToastShowMode::DEFAULT);
123 
GetDialogMap()124     std::unordered_map<int32_t, RefPtr<FrameNode>> GetDialogMap()
125     {
126         return dialogMap_;
127     };
128     RefPtr<FrameNode> GetDialog(int32_t dialogId);
129     // customNode only used by customDialog, pass in nullptr if not customDialog
130     RefPtr<FrameNode> ShowDialog(
131         const DialogProperties& dialogProps, std::function<void()>&& buildFunc, bool isRightToLeft = false);
132     void ShowCustomDialog(const RefPtr<FrameNode>& customNode);
133     void ShowDateDialog(const DialogProperties& dialogProps, const DatePickerSettingData& settingData,
134         std::map<std::string, NG::DialogEvent> dialogEvent,
135         std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent);
136     void ShowTimeDialog(const DialogProperties& dialogProps, const TimePickerSettingData& settingData,
137         std::map<std::string, PickerTime> timePickerProperty, std::map<std::string, NG::DialogEvent> dialogEvent,
138         std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent);
139     void ShowTextDialog(const DialogProperties& dialogProps, const TextPickerSettingData& settingData,
140         std::map<std::string, NG::DialogTextEvent> dialogEvent,
141         std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent);
142     void ShowCalendarDialog(const DialogProperties& dialogProps, const CalendarSettingData& settingData,
143         std::map<std::string, NG::DialogEvent> dialogEvent,
144         std::map<std::string, NG::DialogGestureEvent> dialogCancelEvent);
145     void PopModalDialog(int32_t maskId);
146 
147     void CloseDialog(const RefPtr<FrameNode>& dialogNode);
148 
149     void OpenCustomDialog(const DialogProperties& dialogProps, std::function<void(int32_t)> &&callback);
150     void CloseCustomDialog(const int32_t dialogId);
151 
SetSubWindowId(int32_t subWindowId)152     void SetSubWindowId(int32_t subWindowId)
153     {
154         subWindowId_ = subWindowId;
155     }
GetSubwindowId()156     int32_t GetSubwindowId()
157     {
158         return subWindowId_;
159     }
SetMaskNodeId(int32_t dialogId,int32_t maskId)160     void SetMaskNodeId(int32_t dialogId, int32_t maskId)
161     {
162         maskNodeIdMap_[dialogId] = maskId;
163     }
isMaskNode(int32_t maskId)164     bool isMaskNode(int32_t maskId)
165     {
166         for (auto it = maskNodeIdMap_.begin(); it != maskNodeIdMap_.end(); it++) {
167             if (it->second == maskId) {
168                 return true;
169             }
170         }
171         return false;
172     }
GetMaskNodeIdWithDialogId(int32_t dialogId)173     int32_t GetMaskNodeIdWithDialogId(int32_t dialogId)
174     {
175         int32_t maskNodeId = -1;
176         for (auto it = maskNodeIdMap_.begin(); it != maskNodeIdMap_.end(); it++) {
177             if (it->first == dialogId) {
178                 maskNodeId = it->second;
179                 break;
180             }
181         }
182         return maskNodeId;
183     }
184     /**  pop overlays (if any) on back press
185      *
186      *   @return    true if popup was removed, false if no overlay exists
187      */
188     bool RemoveOverlay(bool isBackPressed, bool isPageRouter = false);
189     bool RemoveDialog(const RefPtr<FrameNode>& overlay, bool isBackPressed, bool isPageRouter);
190     bool RemoveBubble(const RefPtr<FrameNode>& overlay);
191     bool RemoveMenu(const RefPtr<FrameNode>& overlay);
192     bool RemoveModalInOverlay();
193     bool RemoveAllModalInOverlay();
194     bool RemoveOverlayInSubwindow();
195 
RegisterOnHideDialog(std::function<void ()> callback)196     void RegisterOnHideDialog(std::function<void()> callback)
197     {
198         onHideDialogCallback_ = callback;
199     }
200 
CallOnHideDialogCallback()201     void CallOnHideDialogCallback()
202     {
203         if (onHideDialogCallback_) {
204             onHideDialogCallback_();
205         }
206     }
207 
SetBackPressEvent(std::function<bool ()> event)208     void SetBackPressEvent(std::function<bool()> event)
209     {
210         backPressEvent_ = event;
211     }
212 
FireBackPressEvent()213     bool FireBackPressEvent() const
214     {
215         if (backPressEvent_) {
216             return backPressEvent_();
217         }
218         return false;
219     }
220 
GetHasPixelMap()221     bool GetHasPixelMap()
222     {
223         return hasPixelMap_;
224     }
225 
SetHasPixelMap(bool hasPixelMap)226     void SetHasPixelMap(bool hasPixelMap)
227     {
228         hasPixelMap_ = hasPixelMap;
229     }
230 
GetPixelMapNode()231     RefPtr<FrameNode> GetPixelMapNode()
232     {
233         return pixmapColumnNodeWeak_.Upgrade();
234     }
235 
GetPixelMapContentNode()236     RefPtr<FrameNode> GetPixelMapContentNode() const
237     {
238         auto column = pixmapColumnNodeWeak_.Upgrade();
239         if (!column) {
240             return nullptr;
241         }
242         auto imageNode = AceType::DynamicCast<FrameNode>(column->GetFirstChild());
243         return imageNode;
244     }
245 
GetHasFilter()246     bool GetHasFilter()
247     {
248         return hasFilter_;
249     }
250 
SetHasFilter(bool hasFilter)251     void SetHasFilter(bool hasFilter)
252     {
253         hasFilter_ = hasFilter;
254     }
255 
GetHasEvent()256     bool GetHasEvent()
257     {
258         return hasEvent_;
259     }
260 
SetHasEvent(bool hasEvent)261     void SetHasEvent(bool hasEvent)
262     {
263         hasEvent_ = hasEvent;
264     }
265 
GetIsOnAnimation()266     bool GetIsOnAnimation()
267     {
268         return isOnAnimation_;
269     }
270 
SetIsOnAnimation(bool isOnAnimation)271     void SetIsOnAnimation(bool isOnAnimation)
272     {
273         isOnAnimation_ = isOnAnimation;
274     }
275 
SetFilterColumnNode(const RefPtr<FrameNode> & columnNode)276     void SetFilterColumnNode(const RefPtr<FrameNode>& columnNode)
277     {
278         filterColumnNodeWeak_ = columnNode;
279     }
280     void MountFilterToWindowScene(const RefPtr<FrameNode>& columnNode, const RefPtr<UINode>& windowScene);
281     void MountPixelMapToWindowScene(const RefPtr<FrameNode>& columnNode, const RefPtr<UINode>& windowScene);
282     void MountEventToWindowScene(const RefPtr<FrameNode>& columnNode, const RefPtr<UINode>& windowScene);
283     void MountPixelMapToRootNode(const RefPtr<FrameNode>& columnNode);
284     void MountEventToRootNode(const RefPtr<FrameNode>& columnNode);
285     void RemovePixelMap();
286     void RemovePixelMapAnimation(bool startDrag, double x, double y);
287     void UpdatePixelMapScale(float& scale);
288     void RemoveFilter();
289     void RemoveFilterAnimation();
290     void RemoveEventColumn();
291     void UpdateContextMenuDisappearPosition(const NG::OffsetF& offset);
292 
ResetContextMenuDragHideFinished()293     void ResetContextMenuDragHideFinished()
294     {
295         isContextMenuDragHideFinished_ = false;
296         dragMoveVector_ = OffsetF(0.0f, 0.0f);
297         lastDragMoveVector_ = OffsetF(0.0f, 0.0f);
298     }
299 
SetContextMenuDragHideFinished(bool isContextMenuDragHideFinished)300     void SetContextMenuDragHideFinished(bool isContextMenuDragHideFinished)
301     {
302         isContextMenuDragHideFinished_ = isContextMenuDragHideFinished;
303     }
304 
IsContextMenuDragHideFinished()305     bool IsContextMenuDragHideFinished() const
306     {
307         return isContextMenuDragHideFinished_ == true;
308     }
309 
IsOriginDragMoveVector()310     bool IsOriginDragMoveVector() const
311     {
312         return dragMoveVector_.NonOffset() && lastDragMoveVector_.NonOffset();
313     }
314 
IsUpdateDragMoveVector()315     bool IsUpdateDragMoveVector() const
316     {
317         return !GetUpdateDragMoveVector().NonOffset() && !lastDragMoveVector_.NonOffset();
318     }
319 
UpdateDragMoveVector(const NG::OffsetF & offset)320     void UpdateDragMoveVector(const NG::OffsetF& offset)
321     {
322         lastDragMoveVector_ = dragMoveVector_;
323         dragMoveVector_ = offset;
324     }
325 
GetUpdateDragMoveVector()326     OffsetF GetUpdateDragMoveVector() const
327     {
328         return dragMoveVector_ - lastDragMoveVector_;
329     }
330 
331     void BindContentCover(bool isShow, std::function<void(const std::string&)>&& callback,
332         std::function<RefPtr<UINode>()>&& buildNodeFunc, NG::ModalStyle& modalStyle, std::function<void()>&& onAppear,
333         std::function<void()>&& onDisappear, const RefPtr<FrameNode>& targetNode, int32_t sessionId = 0);
334 
335     void BindSheet(bool isShow, std::function<void(const std::string&)>&& callback,
336         std::function<RefPtr<UINode>()>&& buildNodeFunc, std::function<RefPtr<UINode>()>&& buildTitleNodeFunc,
337         NG::SheetStyle& sheetStyle, std::function<void()>&& onAppear, std::function<void()>&& onDisappear,
338         std::function<void()>&& shouldDismiss, const RefPtr<FrameNode>& targetNode);
339     void OnBindSheet(bool isShow, std::function<void(const std::string&)>&& callback,
340         std::function<RefPtr<UINode>()>&& buildNodeFunc, std::function<RefPtr<UINode>()>&& buildtitleNodeFunc,
341         NG::SheetStyle& sheetStyle, std::function<void()>&& onAppear, std::function<void()>&& onDisappear,
342         std::function<void()>&& shouldDismiss, const RefPtr<FrameNode>& targetNode);
343     void CloseSheet(int32_t targetId);
344 
345     void DismissSheet();
346 
SetDismissTargetId(int32_t targetId)347     void SetDismissTargetId(int32_t targetId)
348     {
349         dismissTargetId_ = targetId;
350     }
351 
352     void RemoveSheetNode(const RefPtr<FrameNode>& sheetNode);
353 
354     void DestroySheet(const RefPtr<FrameNode>& sheetNode, int32_t targetId);
355 
356     RefPtr<FrameNode> GetSheetMask(const RefPtr<FrameNode>& sheetNode);
357 
358     void DeleteModal(int32_t targetId);
359 
360     void RemoveSheetMask(RefPtr<FrameNode>& sheetNode, RefPtr<UINode>& rootNode);
361 
362     void BindKeyboard(const std::function<void()>& keyboardBuilder, int32_t targetId);
363     void CloseKeyboard(int32_t targetId);
364     void DestroyKeyboard();
365 
366     RefPtr<UINode> FindWindowScene(RefPtr<FrameNode> targetNode);
367 
368     // ui extension
369     int32_t CreateModalUIExtension(const AAFwk::Want& want, const ModalUIExtensionCallbacks& callbacks,
370         bool isProhibitBack, bool isAsyncModalBinding = false);
371     void CloseModalUIExtension(int32_t sessionId);
372 
373     RefPtr<FrameNode> BindUIExtensionToMenu(const RefPtr<FrameNode>& uiExtNode,
374         const RefPtr<NG::FrameNode>& targetNode,  std::string longestContent, int32_t menuSize);
375     SizeF CaculateMenuSize(const RefPtr<FrameNode>& menuNode,  std::string longestContent, int32_t menuSize);
376     bool ShowUIExtensionMenu(const RefPtr<NG::FrameNode>& uiExtNode, NG::RectF aiRect, std::string longestContent,
377         int32_t menuSize, const RefPtr<NG::FrameNode>& targetNode);
378 
379     void MarkDirty(PropertyChangeFlag flag);
380     float GetRootHeight() const;
381 
382     void PlaySheetMaskTransition(RefPtr<FrameNode> maskNode, bool isTransitionIn, bool needTransparent = false);
383 
384     void PlaySheetTransition(RefPtr<FrameNode> sheetNode, bool isTransitionIn, bool isFirstTransition = true,
385         bool isModeChangeToAuto = false);
386 
387     void ComputeSheetOffset(NG::SheetStyle& sheetStyle, RefPtr<FrameNode> sheetNode);
388 
389     void ComputeSingleGearSheetOffset(NG::SheetStyle& sheetStyle, RefPtr<FrameNode> sheetNode);
390 
391     void ComputeDetentsSheetOffset(NG::SheetStyle& sheetStyle, RefPtr<FrameNode> sheetNode);
392 
SetSheetHeight(float height)393     void SetSheetHeight(float height)
394     {
395         sheetHeight_ = height;
396     }
397 
GetRootNode()398     const WeakPtr<UINode>& GetRootNode() const
399     {
400         return rootNodeWeak_;
401     }
402 
403     void ModalPageLostFocus(const RefPtr<FrameNode>& node);
404 
405 private:
406     void PopToast(int32_t targetId);
407 
408     // toast should contain id to avoid multiple delete.
409     std::unordered_map<int32_t, WeakPtr<FrameNode>> toastMap_;
410 
411     /**  find/register menu node and update menu's display position
412      *
413      *   @return     true if process is successful
414      */
415     bool ShowMenuHelper(RefPtr<FrameNode>& menu, int32_t targetId, const NG::OffsetF& offset);
416 
417     // The focus logic of overlay node (menu and dialog):
418     // 1. before start show animation: lower level node set unfocusabel and lost focus;
419     // 2. end show animation: overlay node get focus;
420     // 3. before start hide animation: lower level node set focusable;
421     // 4. end hide animation: overlay node lost focus, lower level node get focus.
422     void FocusOverlayNode(const RefPtr<FrameNode>& overlayNode, bool isInSubWindow = false);
423     void BlurOverlayNode(const RefPtr<FrameNode>& currentOverlay, bool isInSubWindow = false);
424     void BlurLowerNode(const RefPtr<FrameNode>& currentOverlay);
425     void ResetLowerNodeFocusable(const RefPtr<FrameNode>& currentOverlay);
426     void PostDialogFinishEvent(const WeakPtr<FrameNode>& nodeWk);
427     void OnDialogCloseEvent(const RefPtr<FrameNode>& node);
428 
429     void CloseDialogInner(const RefPtr<FrameNode>& dialogNode);
430 
431     void ShowMenuAnimation(const RefPtr<FrameNode>& menu);
432     void PopMenuAnimation(const RefPtr<FrameNode>& menu, bool showPreviewAnimation = true, bool startDrag = false);
433     void ClearMenuAnimation(const RefPtr<FrameNode>& menu, bool showPreviewAnimation = true, bool startDrag = false);
434     void ShowMenuClearAnimation(const RefPtr<FrameNode>& menu, AnimationOption& option,
435         bool showPreviewAnimation, bool startDrag);
436 
437     void OpenDialogAnimation(const RefPtr<FrameNode>& node);
438     void CloseDialogAnimation(const RefPtr<FrameNode>& node);
439     void SetContainerButtonEnable(bool isEnabled);
440 
441     void SaveLastModalNode();
442     void PlayDefaultModalTransition(const RefPtr<FrameNode>& modalNode, bool isTransitionIn);
443     void DefaultModalTransition(bool isTransitionIn);
444     void PlayAlphaModalTransition(const RefPtr<FrameNode>& modalNode, bool isTransitionIn);
445     void FireModalPageShow();
446     void FireModalPageHide();
447 
448     void SetSheetBackgroundBlurStyle(const RefPtr<FrameNode>& sheetNode, const BlurStyleOption& bgBlurStyle);
449 
450     bool ModalExitProcess(const RefPtr<FrameNode>& topModalNode);
451     bool ModalPageExitProcess(const RefPtr<FrameNode>& topModalNode);
452     bool SheetPageExitProcess(const RefPtr<FrameNode>& topModalNode);
453 
454     void BeforeShowDialog(const RefPtr<FrameNode>& dialogNode);
455     void RemoveDialogFromMap(const RefPtr<FrameNode>& node);
456     bool DialogInMapHoldingFocus();
457     void PlayKeyboardTransition(RefPtr<FrameNode> customKeyboard, bool isTransitionIn);
458     void FireNavigationStateChange(bool show, const RefPtr<UINode>& node = nullptr);
459     RefPtr<FrameNode> GetModalNodeInStack(std::stack<WeakPtr<FrameNode>>& stack);
460     void PlayBubbleStyleSheetTransition(RefPtr<FrameNode> sheetNode, bool isTransitionIn);
461     void CheckReturnFocus(RefPtr<FrameNode> node);
462     void MountPopup(int32_t targetId, const PopupInfo& popupInfo);
463 
464     // Key: target Id, Value: PopupInfo
465     std::unordered_map<int32_t, NG::PopupInfo> popupMap_;
466     // K: target frameNode ID, V: menuNode
467     std::unordered_map<int32_t, RefPtr<FrameNode>> menuMap_;
468     std::unordered_map<int32_t, RefPtr<FrameNode>> dialogMap_;
469     std::unordered_map<int32_t, RefPtr<FrameNode>> customPopupMap_;
470     std::unordered_map<int32_t, RefPtr<FrameNode>> customKeyboardMap_;
471     std::stack<WeakPtr<FrameNode>> modalStack_;
472     std::list<WeakPtr<FrameNode>> modalList_;
473     std::unordered_map<int32_t, WeakPtr<FrameNode>> sheetMap_;
474     WeakPtr<FrameNode> lastModalNode_; // Previous Modal Node
475     float sheetHeight_ { 0.0 };
476     WeakPtr<UINode> rootNodeWeak_;
477     int32_t dialogCount_ = 0;
478     int32_t dismissTargetId_ = 0;
479     std::unordered_map<int32_t, int32_t> maskNodeIdMap_;
480     int32_t subWindowId_;
481     bool hasPixelMap_ { false };
482     bool hasFilter_ { false };
483     bool hasEvent_ { false };
484     bool isOnAnimation_ { false };
485     WeakPtr<FrameNode> pixmapColumnNodeWeak_;
486     WeakPtr<FrameNode> filterColumnNodeWeak_;
487     WeakPtr<FrameNode> eventColumnNodeWeak_;
488     bool isContextMenuDragHideFinished_ = false;
489     OffsetF dragMoveVector_ = OffsetF(0.0f, 0.0f);
490     OffsetF lastDragMoveVector_ = OffsetF(0.0f, 0.0f);
491 
492     std::function<void()> onHideDialogCallback_ = nullptr;
493     CancelableCallback<void()> continuousTask_;
494     std::function<bool()> backPressEvent_ = nullptr;
495 
496     std::set<WeakPtr<UINode>> windowSceneSet_;
497 
498     RefPtr<NG::ClickEvent> sheetMaskClickEvent_;
499 
500     // native modal ui extension
501     bool isProhibitBack_ = false;
502 
503     std::unordered_map<int32_t, WeakPtr<FrameNode>> uiExtNodes_;
504 
505     ACE_DISALLOW_COPY_AND_MOVE(OverlayManager);
506 };
507 } // namespace OHOS::Ace::NG
508 
509 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_OVERLAY_OVERLAY_MANAGER_H
510