• 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_EVENT_EVENT_HUB_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
18 
19 #include <list>
20 #include <utility>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/memory/referenced.h"
24 #include "base/utils/noncopyable.h"
25 #include "core/components_ng/event/focus_hub.h"
26 #include "core/components_ng/event/gesture_event_hub.h"
27 #include "core/components_ng/event/input_event_hub.h"
28 #include "core/components_ng/event/state_style_manager.h"
29 
30 namespace OHOS::Ace::NG {
31 
32 class FrameNode;
33 class InspectorFilter;
34 
35 using OnAreaChangedFunc =
36     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>;
37 using OnPreDragFunc = std::function<void(const PreDragStatus)>;
38 
39 using OnSizeChangedFunc = std::function<void(const RectF& oldRect, const RectF& rect)>;
40 
41 struct KeyboardShortcut {
42     std::string value;
43     uint8_t keys = 0;
44     std::function<void()> onKeyboardShortcutAction = nullptr;
IsEqualTriggerKeyboardShortcut45     bool IsEqualTrigger(const KeyboardShortcut& other)
46     {
47         return (keys == other.keys) && (value == other.value);
48     }
49 };
50 
51 enum class DragFuncType {
52     DRAG_ENTER,
53     DRAG_LEAVE,
54     DRAG_MOVE,
55     DRAG_DROP,
56     DRAG_END,
57 };
58 
59 enum class VisibleAreaChangeTriggerReason : int32_t {
60     IDLE = 0,
61     VISIBLE_AREA_CHANGE = 1,
62     DETACH_FROM_MAINTREE = 2,
63     BACKGROUND = 3,
64     SELF_INVISIBLE = 4,
65     FRAMENODE_DESTROY = 5,
66     IS_NOT_ON_MAINTREE = 6,
67     ANCESTOR_INVISIBLE = 7,
68 };
69 
70 // The event hub is mainly used to handle common collections of events, such as gesture events, mouse events, etc.
71 class ACE_FORCE_EXPORT EventHub : public virtual AceType {
72     DECLARE_ACE_TYPE(EventHub, AceType)
73 
74 public:
75     EventHub() = default;
~EventHub()76     ~EventHub() override
77     {
78         keyboardShortcut_.clear();
79     };
80 
GetOrCreateGestureEventHub()81     const RefPtr<GestureEventHub>& GetOrCreateGestureEventHub()
82     {
83         if (!gestureEventHub_) {
84             gestureEventHub_ = CreateGestureEventHub();
85         }
86         return gestureEventHub_;
87     }
88 
CreateGestureEventHub()89     virtual RefPtr<GestureEventHub> CreateGestureEventHub()
90     {
91         return MakeRefPtr<GestureEventHub>(WeakClaim(this));
92     }
93 
GetGestureEventHub()94     const RefPtr<GestureEventHub>& GetGestureEventHub() const
95     {
96         return gestureEventHub_;
97     }
98 
SetGestureEventHub(const RefPtr<GestureEventHub> & gestureEventHub)99     void SetGestureEventHub(const RefPtr<GestureEventHub>& gestureEventHub)
100     {
101         gestureEventHub_ = gestureEventHub;
102     }
103 
GetOrCreateInputEventHub()104     const RefPtr<InputEventHub>& GetOrCreateInputEventHub()
105     {
106         if (!inputEventHub_) {
107             inputEventHub_ = MakeRefPtr<InputEventHub>(WeakClaim(this));
108         }
109         return inputEventHub_;
110     }
111 
GetInputEventHub()112     const RefPtr<InputEventHub>& GetInputEventHub() const
113     {
114         return inputEventHub_;
115     }
116 
117     const RefPtr<FocusHub>& GetOrCreateFocusHub(FocusType type = FocusType::DISABLE, bool focusable = false,
118         FocusStyleType focusStyleType = FocusStyleType::NONE,
119         const std::unique_ptr<FocusPaintParam>& paintParamsPtr = nullptr)
120     {
121         if (!focusHub_) {
122             focusHub_ = MakeRefPtr<FocusHub>(WeakClaim(this), type, focusable);
123             focusHub_->SetFocusStyleType(focusStyleType);
124             if (paintParamsPtr) {
125                 focusHub_->SetFocusPaintParamsPtr(paintParamsPtr);
126             }
127         }
128         return focusHub_;
129     }
130 
GetOrCreateFocusHub(const FocusPattern & focusPattern)131     const RefPtr<FocusHub>& GetOrCreateFocusHub(const FocusPattern& focusPattern)
132     {
133         if (!focusHub_) {
134             focusHub_ = MakeRefPtr<FocusHub>(WeakClaim(this), focusPattern);
135         }
136         return focusHub_;
137     }
138 
GetFocusHub()139     const RefPtr<FocusHub>& GetFocusHub() const
140     {
141         return focusHub_;
142     }
143 
144     void AttachHost(const WeakPtr<FrameNode>& host);
145     void OnAttachContext(PipelineContext *context);
146     void OnDetachContext(PipelineContext *context);
147 
148     RefPtr<FrameNode> GetFrameNode() const;
149 
150     GetEventTargetImpl CreateGetEventTargetImpl() const;
151 
OnContextAttached()152     void OnContextAttached()
153     {
154         if (gestureEventHub_) {
155             gestureEventHub_->OnContextAttached();
156         }
157     }
158 
ClearUserOnAppear()159     void ClearUserOnAppear()
160     {
161         if (onAppear_) {
162             onAppear_ = nullptr;
163         }
164     }
165 
SetOnAppear(std::function<void ()> && onAppear)166     void SetOnAppear(std::function<void()>&& onAppear)
167     {
168         onAppear_ = std::move(onAppear);
169     }
170 
171     void SetJSFrameNodeOnAppear(std::function<void()>&& onAppear);
172 
173     void ClearJSFrameNodeOnAppear();
174 
175     virtual void FireOnAppear();
176 
ClearUserOnDisAppear()177     void ClearUserOnDisAppear()
178     {
179         if (onDisappear_) {
180             onDisappear_ = nullptr;
181         }
182     }
183 
SetOnDisappear(std::function<void ()> && onDisappear)184     void SetOnDisappear(std::function<void()>&& onDisappear)
185     {
186         onDisappear_ = std::move(onDisappear);
187     }
188 
189     void SetJSFrameNodeOnDisappear(std::function<void()>&& onDisappear);
190 
191     void ClearJSFrameNodeOnDisappear();
192 
193     virtual void FireOnDisappear();
194 
ClearUserOnAreaChanged()195     void ClearUserOnAreaChanged()
196     {
197         if (onAreaChanged_) {
198             onAreaChanged_ = nullptr;
199         }
200     }
201 
SetOnAreaChanged(OnAreaChangedFunc && onAreaChanged)202     void SetOnAreaChanged(OnAreaChangedFunc&& onAreaChanged)
203     {
204         onAreaChanged_ = std::move(onAreaChanged);
205     }
206 
FireOnAreaChanged(const RectF & oldRect,const OffsetF & oldOrigin,const RectF & rect,const OffsetF & origin)207     void FireOnAreaChanged(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)
208     {
209         if (onAreaChanged_) {
210             // callback may be overwritten in its invoke so we copy it first
211             auto onAreaChanged = onAreaChanged_;
212             onAreaChanged(oldRect, oldOrigin, rect, origin);
213         }
214     }
215 
FireInnerOnAreaChanged(const RectF & oldRect,const OffsetF & oldOrigin,const RectF & rect,const OffsetF & origin)216     void FireInnerOnAreaChanged(
217         const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)
218     {
219         for (auto& innerCallbackInfo : onAreaChangedInnerCallbacks_) {
220             if (innerCallbackInfo.second) {
221                 auto innerOnAreaCallback = innerCallbackInfo.second;
222                 innerOnAreaCallback(oldRect, oldOrigin, rect, origin);
223             }
224         }
225     }
226 
HasOnAreaChanged()227     bool HasOnAreaChanged() const
228     {
229         return static_cast<bool>(onAreaChanged_);
230     }
231 
HasInnerOnAreaChanged()232     bool HasInnerOnAreaChanged() const
233     {
234         return !onAreaChangedInnerCallbacks_.empty();
235     }
236 
237     void SetOnSizeChanged(OnSizeChangedFunc&& onSizeChanged);
238     void FireOnSizeChanged(const RectF& oldRect, const RectF& rect);
239     bool HasOnSizeChanged() const;
240 
241     void AddInnerOnSizeChanged(int32_t id, OnSizeChangedFunc&& onSizeChanged);
242     void FireInnerOnSizeChanged(const RectF& oldRect, const RectF& rect);
243     bool HasInnerOnSizeChanged() const;
244     void ClearInnerOnSizeChanged();
245 
246     void SetJSFrameNodeOnSizeChangeCallback(OnSizeChangedFunc&& onSizeChanged);
247     void FireJSFrameNodeOnSizeChanged(const RectF& oldRect, const RectF& rect);
248     void ClearJSFrameNodeOnSizeChange();
249     using OnDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
250     using OnNewDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)>;
251     using OnDragStartFunc = std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
252 
SetOnPreDrag(OnPreDragFunc && onPreDragFunc)253     void SetOnPreDrag(OnPreDragFunc&& onPreDragFunc)
254     {
255         onPreDragFunc_ = std::move(onPreDragFunc);
256     }
257 
GetOnPreDrag()258     const OnPreDragFunc& GetOnPreDrag() const
259     {
260         return onPreDragFunc_;
261     }
262 
SetOnDragStart(OnDragStartFunc && onDragStart)263     void SetOnDragStart(OnDragStartFunc&& onDragStart)
264     {
265         onDragStart_ = std::move(onDragStart);
266     }
267 
GetOnDragStart()268     const OnDragStartFunc& GetOnDragStart() const
269     {
270         return onDragStart_;
271     }
272 
HasOnDragStart()273     bool HasOnDragStart() const
274     {
275         return static_cast<bool>(onDragStart_) || static_cast<bool>(defaultOnDragStart_);
276     }
277 
SetOnDragEnter(OnDragFunc && onDragEnter)278     void SetOnDragEnter(OnDragFunc&& onDragEnter)
279     {
280         onDragEnter_ = std::move(onDragEnter);
281     }
282 
283     void FireOnDragEnter(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
284 
SetOnDragLeave(OnDragFunc && onDragLeave)285     void SetOnDragLeave(OnDragFunc&& onDragLeave)
286     {
287         onDragLeave_ = std::move(onDragLeave);
288     }
289 
290     void FireOnDragLeave(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
291 
SetOnDragMove(OnDragFunc && onDragMove)292     void SetOnDragMove(OnDragFunc&& onDragMove)
293     {
294         onDragMove_ = std::move(onDragMove);
295     }
296 
297     void FireOnDragMove(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
298 
HasOnDragMove()299     bool HasOnDragMove() const
300     {
301         return static_cast<bool>(onDragMove_);
302     }
303 
SetOnDrop(OnDragFunc && onDrop)304     void SetOnDrop(OnDragFunc&& onDrop)
305     {
306         onDrop_ = std::move(onDrop);
307     }
308 
SetOnDragEnd(OnNewDragFunc && onDragEnd)309     void SetOnDragEnd(OnNewDragFunc&& onDragEnd)
310     {
311         onDragEnd_ = std::move(onDragEnd);
312     }
313 
GetOnDragEnd()314     const OnNewDragFunc& GetOnDragEnd() const
315     {
316         return onDragEnd_;
317     }
318 
HasOnDragEnter()319     bool HasOnDragEnter() const
320     {
321         return static_cast<bool>(onDragEnter_);
322     }
323 
HasOnDragLeave()324     bool HasOnDragLeave() const
325     {
326         return static_cast<bool>(onDragLeave_);
327     }
328 
HasOnDragEnd()329     bool HasOnDragEnd() const
330     {
331         return static_cast<bool>(onDragEnd_);
332     }
333 
HasOnItemDragMove()334     virtual bool HasOnItemDragMove()
335     {
336         return false;
337     }
338 
HasOnItemDrop()339     virtual bool HasOnItemDrop()
340     {
341         return false;
342     }
343 
344     void FireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
345 
HasOnDrop()346     bool HasOnDrop() const
347     {
348         return onDrop_ != nullptr;
349     }
350 
HasCustomerOnDragEnter()351     bool HasCustomerOnDragEnter() const
352     {
353         return customerOnDragEnter_ != nullptr;
354     }
355 
HasCustomerOnDragLeave()356     bool HasCustomerOnDragLeave() const
357     {
358         return customerOnDragLeave_ != nullptr;
359     }
360 
HasCustomerOnDragMove()361     bool HasCustomerOnDragMove() const
362     {
363         return customerOnDragMove_ != nullptr;
364     }
365 
HasCustomerOnDragEnd()366     bool HasCustomerOnDragEnd() const
367     {
368         return customerOnDragEnd_ != nullptr;
369     }
370 
HasCustomerOnDrop()371     bool HasCustomerOnDrop() const
372     {
373         return customerOnDrop_ != nullptr;
374     }
375 
376     void SetDisableDataPrefetch(bool disableDataPrefetch);
377 
378     bool GetDisableDataPrefetch() const;
379 
GetDragExtraParams(const std::string & extraInfo,const Point & point,DragEventType isStart)380     virtual std::string GetDragExtraParams(const std::string& extraInfo, const Point& point, DragEventType isStart)
381     {
382         auto json = JsonUtil::Create(true);
383         if (!extraInfo.empty()) {
384             json->Put("extraInfo", extraInfo.c_str());
385         }
386         return json->ToString();
387     }
388 
IsEnabled()389     bool IsEnabled() const
390     {
391         return enabled_;
392     }
393 
IsDeveloperEnabled()394     bool IsDeveloperEnabled() const
395     {
396         return developerEnabled_;
397     }
398 
399     void SetEnabled(bool enabled);
400 
SetEnabledInternal(bool enabled)401     void SetEnabledInternal(bool enabled)
402     {
403         enabled_ = enabled;
404     }
405 
406     // restore enabled value to what developer sets
RestoreEnabled()407     void RestoreEnabled()
408     {
409         enabled_ = developerEnabled_;
410     }
411 
412     // get XTS inspector value
ToJsonValue(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)413     virtual void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const {}
414 
FromJson(const std::unique_ptr<JsonValue> & json)415     virtual void FromJson(const std::unique_ptr<JsonValue>& json) {}
416 
417     void MarkModifyDone();
418 
419     void SetCurrentUIState(UIState state, bool flag);
420 
UpdateCurrentUIState(UIState state)421     void UpdateCurrentUIState(UIState state)
422     {
423         if (stateStyleMgr_) {
424             stateStyleMgr_->UpdateCurrentUIState(state);
425         }
426     }
427 
ResetCurrentUIState(UIState state)428     void ResetCurrentUIState(UIState state)
429     {
430         if (stateStyleMgr_) {
431             stateStyleMgr_->ResetCurrentUIState(state);
432         }
433     }
434 
GetCurrentUIState()435     UIState GetCurrentUIState() const
436     {
437         return stateStyleMgr_ ? stateStyleMgr_->GetCurrentUIState() : UI_STATE_NORMAL;
438     }
439 
HasStateStyle(UIState state)440     bool HasStateStyle(UIState state) const
441     {
442         if (stateStyleMgr_) {
443             return stateStyleMgr_->HasStateStyle(state);
444         }
445         return false;
446     }
447 
448     void AddSupportedState(UIState state);
449 
450     void SetSupportedStates(UIState state);
451 
452     bool IsCurrentStateOn(UIState state);
453 
SetKeyboardShortcut(const std::string & value,uint8_t keys,const std::function<void ()> & onKeyboardShortcutAction)454     void SetKeyboardShortcut(
455         const std::string& value, uint8_t keys, const std::function<void()>& onKeyboardShortcutAction)
456     {
457         TAG_LOGI(
458             AceLogTag::ACE_KEYBOARD, "SetKeyboardShortcut value = %{public}s, keys = %{public}d", value.c_str(), keys);
459         KeyboardShortcut keyboardShortcut;
460         for (auto&& ch : value) {
461             keyboardShortcut.value.push_back(static_cast<char>(std::toupper(ch)));
462         }
463         keyboardShortcut.keys = keys;
464         keyboardShortcut.onKeyboardShortcutAction = onKeyboardShortcutAction;
465 
466         for (auto& shortCut : keyboardShortcut_) {
467             if (shortCut.IsEqualTrigger(keyboardShortcut)) {
468                 shortCut.onKeyboardShortcutAction = onKeyboardShortcutAction;
469                 return;
470             }
471         }
472         keyboardShortcut_.emplace_back(keyboardShortcut);
473     }
474 
ClearSingleKeyboardShortcut()475     void ClearSingleKeyboardShortcut()
476     {
477         if (keyboardShortcut_.size() == 1) {
478             keyboardShortcut_.clear();
479         }
480     }
481 
GetKeyboardShortcut()482     std::vector<KeyboardShortcut>& GetKeyboardShortcut()
483     {
484         return keyboardShortcut_;
485     }
486 
487     void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnDragFunc&& onDragFunc);
488 
489     void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnNewDragFunc&& onDragEnd);
490 
GetCustomerOnDragFunc(DragFuncType dragFuncType)491     const OnDragFunc GetCustomerOnDragFunc(DragFuncType dragFuncType) const
492     {
493         OnDragFunc dragFunc;
494         switch (dragFuncType) {
495             case DragFuncType::DRAG_ENTER:
496                 dragFunc = customerOnDragEnter_;
497                 break;
498             case DragFuncType::DRAG_LEAVE:
499                 dragFunc = customerOnDragLeave_;
500                 break;
501             case DragFuncType::DRAG_MOVE:
502                 dragFunc = customerOnDragMove_;
503                 break;
504             case DragFuncType::DRAG_DROP:
505                 dragFunc = customerOnDrop_;
506                 break;
507             default:
508                 LOGW("unsuport dragFuncType");
509                 break;
510         }
511         return dragFunc;
512     }
513 
GetCustomerOnDragEndFunc()514     const OnNewDragFunc& GetCustomerOnDragEndFunc() const
515     {
516         return customerOnDragEnd_;
517     }
518 
519     void ClearCustomerOnDragFunc();
520 
521     void ClearCustomerOnDragStart();
522 
523     void ClearCustomerOnDragEnter();
524 
525     void ClearCustomerOnDragMove();
526 
527     void ClearCustomerOnDragLeave();
528 
529     void ClearCustomerOnDrop();
530 
531     void ClearCustomerOnDragEnd();
532 
533     void FireCustomerOnDragFunc(
534         DragFuncType dragFuncType, const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams = "");
535 
536     bool IsFireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info);
537 
538     void HandleInternalOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
539 
540     void PostEnabledTask();
541 
542     void AddInnerOnAreaChangedCallback(int32_t id, OnAreaChangedFunc&& callback);
543 
544     void RemoveInnerOnAreaChangedCallback(int32_t id);
545 
546     void ClearOnAreaChangedInnerCallbacks();
547 
548     bool HasImmediatelyVisibleCallback();
549 
GetThrottledVisibleAreaRatios()550     std::vector<double>& GetThrottledVisibleAreaRatios()
551     {
552         return throttledVisibleAreaRatios_;
553     }
554 
GetThrottledVisibleAreaCallback()555     VisibleCallbackInfo& GetThrottledVisibleAreaCallback()
556     {
557         return throttledVisibleAreaCallback_;
558     }
559 
GetVisibleAreaRatios(bool isUser)560     std::vector<double>& GetVisibleAreaRatios(bool isUser)
561     {
562         if (isUser) {
563             return visibleAreaUserRatios_;
564         } else {
565             return visibleAreaInnerRatios_;
566         }
567     }
568 
GetVisibleAreaCallback(bool isUser)569     VisibleCallbackInfo& GetVisibleAreaCallback(bool isUser)
570     {
571         if (isUser) {
572             return visibleAreaUserCallback_;
573         } else {
574             return visibleAreaInnerCallback_;
575         }
576     }
577 
SetVisibleAreaRatiosAndCallback(const VisibleCallbackInfo & callback,const std::vector<double> & radios,bool isUser)578     void SetVisibleAreaRatiosAndCallback(
579         const VisibleCallbackInfo& callback, const std::vector<double>& radios, bool isUser)
580     {
581         if (isUser) {
582             VisibleCallbackInfo* cbInfo =
583                 (callback.period == 0) ? &visibleAreaUserCallback_ : &throttledVisibleAreaCallback_;
584             auto ratioInfo = (callback.period == 0) ? &visibleAreaUserRatios_ : &throttledVisibleAreaRatios_;
585             *cbInfo = callback;
586             *ratioInfo = radios;
587         } else {
588             visibleAreaInnerCallback_ = callback;
589             visibleAreaInnerRatios_ = radios;
590         }
591     }
592 
593     void CleanVisibleAreaCallback(bool isUser, bool isThrottled = false)
594     {
595         if (!isUser) {
596             visibleAreaInnerRatios_.clear();
597             visibleAreaInnerCallback_.callback = nullptr;
598         } else if (isThrottled) {
599             throttledVisibleAreaRatios_.clear();
600             throttledVisibleAreaCallback_.callback = nullptr;
601         } else {
602             visibleAreaUserRatios_.clear();
603             visibleAreaUserCallback_.callback = nullptr;
604         }
605     }
606 
SetDefaultOnDragStart(OnDragStartFunc && defaultOnDragStart)607     void SetDefaultOnDragStart(OnDragStartFunc&& defaultOnDragStart)
608     {
609         defaultOnDragStart_ = std::move(defaultOnDragStart);
610     }
611 
GetDefaultOnDragStart()612     const OnDragStartFunc& GetDefaultOnDragStart() const
613     {
614         return defaultOnDragStart_;
615     }
616 
HasDefaultOnDragStart()617     bool HasDefaultOnDragStart() const
618     {
619         return static_cast<bool>(defaultOnDragStart_);
620     }
621 
HasVisibleAreaCallback(bool isUser)622     bool HasVisibleAreaCallback(bool isUser)
623     {
624         if (isUser) {
625             return static_cast<bool>(visibleAreaUserCallback_.callback);
626         } else {
627             return static_cast<bool>(visibleAreaInnerCallback_.callback);
628         }
629     }
630 
631     void SetOnAttach(std::function<void()>&& onAttach);
632     void ClearOnAttach();
633     void FireOnAttach();
634     void SetOnDetach(std::function<void()>&& onDetach);
635     void ClearOnDetach();
636     void FireOnDetach();
637     void ClearStateStyle();
638     void OnDetachClear();
639     void FireDrawCompletedNDKCallback(const RefPtr<PipelineContext>& pipeline);
640     void FireLayoutNDKCallback(const RefPtr<PipelineContext>& pipeline);
SetNDKDrawCompletedCallback(std::function<void ()> && callback)641     void SetNDKDrawCompletedCallback(std::function<void()>&& callback)
642     {
643         ndkDrawCompletedCallback_ = std::move(callback);
644     }
SetNDKLayoutCallback(std::function<void ()> && callback)645     void SetNDKLayoutCallback(std::function<void()>&& callback)
646     {
647         ndkLayoutCallback_ = std::move(callback);
648     }
HasNDKDrawCompletedCallback()649     bool HasNDKDrawCompletedCallback()
650     {
651         return !!ndkDrawCompletedCallback_;
652     }
653 
654 
655 protected:
OnModifyDone()656     virtual void OnModifyDone() {}
657     std::function<void()> onAppear_;
658     std::function<void()> onJSFrameNodeAppear_;
659 
660 private:
661     WeakPtr<FrameNode> host_;
662     RefPtr<GestureEventHub> gestureEventHub_;
663     RefPtr<InputEventHub> inputEventHub_;
664     RefPtr<FocusHub> focusHub_;
665     RefPtr<StateStyleManager> stateStyleMgr_;
666 
667     std::function<void()> onDisappear_;
668     std::function<void()> onJSFrameNodeDisappear_;
669     OnAreaChangedFunc onAreaChanged_;
670     std::unordered_map<int32_t, OnAreaChangedFunc> onAreaChangedInnerCallbacks_;
671     OnSizeChangedFunc onSizeChanged_;
672     std::unordered_map<int32_t, OnSizeChangedFunc> onSizeChangedInnerCallbacks_;
673     OnSizeChangedFunc onJsFrameNodeSizeChanged_;
674 
675     std::function<void()> onAttach_;
676     std::function<void()> onDetach_;
677 
678     OnPreDragFunc onPreDragFunc_;
679     OnDragStartFunc onDragStart_;
680     OnDragFunc onDragEnter_;
681     OnDragFunc onDragLeave_;
682     OnDragFunc onDragMove_;
683     OnDragFunc onDrop_;
684     OnNewDragFunc onDragEnd_;
685 
686     OnDragStartFunc defaultOnDragStart_;
687     OnDragFunc customerOnDragEnter_;
688     OnDragFunc customerOnDragLeave_;
689     OnDragFunc customerOnDragMove_;
690     OnDragFunc customerOnDrop_;
691     OnNewDragFunc customerOnDragEnd_;
692 
693     bool enabled_ { true };
694     bool developerEnabled_ { true };
695     bool disableDataPrefetch_ { false };
696     std::vector<KeyboardShortcut> keyboardShortcut_;
697 
698     std::vector<double> visibleAreaUserRatios_;
699     VisibleCallbackInfo visibleAreaUserCallback_;
700     std::vector<double> visibleAreaInnerRatios_;
701     VisibleCallbackInfo visibleAreaInnerCallback_;
702     std::vector<double> throttledVisibleAreaRatios_;
703     VisibleCallbackInfo throttledVisibleAreaCallback_;
704     std::function<void()> ndkDrawCompletedCallback_;
705     std::function<void()> ndkLayoutCallback_;
706 
707     ACE_DISALLOW_COPY_AND_MOVE(EventHub);
708 };
709 
710 class TextCommonEvent : public BaseEventInfo {
DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent,BaseEventInfo)711     DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent, BaseEventInfo)
712 public:
713     TextCommonEvent() : BaseEventInfo("TextCommonEvent") {}
714     ~TextCommonEvent() override = default;
715 };
716 
717 } // namespace OHOS::Ace::NG
718 
719 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
720