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  
GetDragExtraParams(const std::string & extraInfo,const Point & point,DragEventType isStart)376      virtual std::string GetDragExtraParams(const std::string& extraInfo, const Point& point, DragEventType isStart)
377      {
378          auto json = JsonUtil::Create(true);
379          if (!extraInfo.empty()) {
380              json->Put("extraInfo", extraInfo.c_str());
381          }
382          return json->ToString();
383      }
384  
IsEnabled()385      bool IsEnabled() const
386      {
387          return enabled_;
388      }
389  
IsDeveloperEnabled()390      bool IsDeveloperEnabled() const
391      {
392          return developerEnabled_;
393      }
394  
395      void SetEnabled(bool enabled);
396  
SetEnabledInternal(bool enabled)397      void SetEnabledInternal(bool enabled)
398      {
399          enabled_ = enabled;
400      }
401  
402      // restore enabled value to what developer sets
RestoreEnabled()403      void RestoreEnabled()
404      {
405          enabled_ = developerEnabled_;
406      }
407  
408      // get XTS inspector value
ToJsonValue(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)409      virtual void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const {}
410  
FromJson(const std::unique_ptr<JsonValue> & json)411      virtual void FromJson(const std::unique_ptr<JsonValue>& json) {}
412  
413      void MarkModifyDone();
414  
415      void SetCurrentUIState(UIState state, bool flag);
416  
UpdateCurrentUIState(UIState state)417      void UpdateCurrentUIState(UIState state)
418      {
419          if (stateStyleMgr_) {
420              stateStyleMgr_->UpdateCurrentUIState(state);
421          }
422      }
423  
ResetCurrentUIState(UIState state)424      void ResetCurrentUIState(UIState state)
425      {
426          if (stateStyleMgr_) {
427              stateStyleMgr_->ResetCurrentUIState(state);
428          }
429      }
430  
GetCurrentUIState()431      UIState GetCurrentUIState() const
432      {
433          return stateStyleMgr_ ? stateStyleMgr_->GetCurrentUIState() : UI_STATE_NORMAL;
434      }
435  
HasStateStyle(UIState state)436      bool HasStateStyle(UIState state) const
437      {
438          if (stateStyleMgr_) {
439              return stateStyleMgr_->HasStateStyle(state);
440          }
441          return false;
442      }
443  
444      void AddSupportedState(UIState state);
445  
446      void SetSupportedStates(UIState state);
447  
448      bool IsCurrentStateOn(UIState state);
449  
SetKeyboardShortcut(const std::string & value,uint8_t keys,const std::function<void ()> & onKeyboardShortcutAction)450      void SetKeyboardShortcut(
451          const std::string& value, uint8_t keys, const std::function<void()>& onKeyboardShortcutAction)
452      {
453          KeyboardShortcut keyboardShortcut;
454          for (auto&& ch : value) {
455              keyboardShortcut.value.push_back(static_cast<char>(std::toupper(ch)));
456          }
457          keyboardShortcut.keys = keys;
458          keyboardShortcut.onKeyboardShortcutAction = onKeyboardShortcutAction;
459  
460          for (auto& shortCut : keyboardShortcut_) {
461              if (shortCut.IsEqualTrigger(keyboardShortcut)) {
462                  shortCut.onKeyboardShortcutAction = onKeyboardShortcutAction;
463                  return;
464              }
465          }
466          keyboardShortcut_.emplace_back(keyboardShortcut);
467      }
468  
ClearSingleKeyboardShortcut()469      void ClearSingleKeyboardShortcut()
470      {
471          if (keyboardShortcut_.size() == 1) {
472              keyboardShortcut_.clear();
473          }
474      }
475  
GetKeyboardShortcut()476      std::vector<KeyboardShortcut>& GetKeyboardShortcut()
477      {
478          return keyboardShortcut_;
479      }
480  
481      void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnDragFunc&& onDragFunc);
482  
483      void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnNewDragFunc&& onDragEnd);
484  
GetCustomerOnDragFunc(DragFuncType dragFuncType)485      const OnDragFunc GetCustomerOnDragFunc(DragFuncType dragFuncType) const
486      {
487          OnDragFunc dragFunc;
488          switch (dragFuncType) {
489              case DragFuncType::DRAG_ENTER:
490                  dragFunc = customerOnDragEnter_;
491                  break;
492              case DragFuncType::DRAG_LEAVE:
493                  dragFunc = customerOnDragLeave_;
494                  break;
495              case DragFuncType::DRAG_MOVE:
496                  dragFunc = customerOnDragMove_;
497                  break;
498              case DragFuncType::DRAG_DROP:
499                  dragFunc = customerOnDrop_;
500                  break;
501              default:
502                  LOGW("unsuport dragFuncType");
503                  break;
504          }
505          return dragFunc;
506      }
507  
GetCustomerOnDragEndFunc()508      const OnNewDragFunc& GetCustomerOnDragEndFunc() const
509      {
510          return customerOnDragEnd_;
511      }
512  
513      void ClearCustomerOnDragFunc();
514  
515      void ClearCustomerOnDragStart();
516  
517      void ClearCustomerOnDragEnter();
518  
519      void ClearCustomerOnDragMove();
520  
521      void ClearCustomerOnDragLeave();
522  
523      void ClearCustomerOnDrop();
524  
525      void ClearCustomerOnDragEnd();
526  
527      void FireCustomerOnDragFunc(
528          DragFuncType dragFuncType, const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams = "");
529  
530      bool IsFireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info);
531  
532      void HandleInternalOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
533  
534      void PostEnabledTask();
535  
536      void AddInnerOnAreaChangedCallback(int32_t id, OnAreaChangedFunc&& callback);
537  
538      void RemoveInnerOnAreaChangedCallback(int32_t id);
539  
540      void ClearOnAreaChangedInnerCallbacks();
541  
542      bool HasImmediatelyVisibleCallback();
543  
GetThrottledVisibleAreaRatios()544      std::vector<double>& GetThrottledVisibleAreaRatios()
545      {
546          return throttledVisibleAreaRatios_;
547      }
548  
GetThrottledVisibleAreaCallback()549      VisibleCallbackInfo& GetThrottledVisibleAreaCallback()
550      {
551          return throttledVisibleAreaCallback_;
552      }
553  
GetVisibleAreaRatios(bool isUser)554      std::vector<double>& GetVisibleAreaRatios(bool isUser)
555      {
556          if (isUser) {
557              return visibleAreaUserRatios_;
558          } else {
559              return visibleAreaInnerRatios_;
560          }
561      }
562  
GetVisibleAreaCallback(bool isUser)563      VisibleCallbackInfo& GetVisibleAreaCallback(bool isUser)
564      {
565          if (isUser) {
566              return visibleAreaUserCallback_;
567          } else {
568              return visibleAreaInnerCallback_;
569          }
570      }
571  
SetVisibleAreaRatiosAndCallback(const VisibleCallbackInfo & callback,const std::vector<double> & radios,bool isUser)572      void SetVisibleAreaRatiosAndCallback(
573          const VisibleCallbackInfo& callback, const std::vector<double>& radios, bool isUser)
574      {
575          if (isUser) {
576              VisibleCallbackInfo* cbInfo =
577                  (callback.period == 0) ? &visibleAreaUserCallback_ : &throttledVisibleAreaCallback_;
578              auto ratioInfo = (callback.period == 0) ? &visibleAreaUserRatios_ : &throttledVisibleAreaRatios_;
579              *cbInfo = callback;
580              *ratioInfo = radios;
581          } else {
582              visibleAreaInnerCallback_ = callback;
583              visibleAreaInnerRatios_ = radios;
584          }
585      }
586  
587      void CleanVisibleAreaCallback(bool isUser, bool isThrottled = false)
588      {
589          if (!isUser) {
590              visibleAreaInnerRatios_.clear();
591              visibleAreaInnerCallback_.callback = nullptr;
592          } else if (isThrottled) {
593              throttledVisibleAreaRatios_.clear();
594              throttledVisibleAreaCallback_.callback = nullptr;
595          } else {
596              visibleAreaUserRatios_.clear();
597              visibleAreaUserCallback_.callback = nullptr;
598          }
599      }
600  
SetDefaultOnDragStart(OnDragStartFunc && defaultOnDragStart)601      void SetDefaultOnDragStart(OnDragStartFunc&& defaultOnDragStart)
602      {
603          defaultOnDragStart_ = std::move(defaultOnDragStart);
604      }
605  
GetDefaultOnDragStart()606      const OnDragStartFunc& GetDefaultOnDragStart() const
607      {
608          return defaultOnDragStart_;
609      }
610  
HasDefaultOnDragStart()611      bool HasDefaultOnDragStart() const
612      {
613          return static_cast<bool>(defaultOnDragStart_);
614      }
615  
HasVisibleAreaCallback(bool isUser)616      bool HasVisibleAreaCallback(bool isUser)
617      {
618          if (isUser) {
619              return static_cast<bool>(visibleAreaUserCallback_.callback);
620          } else {
621              return static_cast<bool>(visibleAreaInnerCallback_.callback);
622          }
623      }
624  
625      void SetOnAttach(std::function<void()>&& onAttach);
626      void ClearOnAttach();
627      void FireOnAttach();
628      void SetOnDetach(std::function<void()>&& onDetach);
629      void ClearOnDetach();
630      void FireOnDetach();
631      void ClearStateStyle();
632      void OnDetachClear();
633  
634  protected:
OnModifyDone()635      virtual void OnModifyDone() {}
636      std::function<void()> onAppear_;
637      std::function<void()> onJSFrameNodeAppear_;
638  
639  private:
640      WeakPtr<FrameNode> host_;
641      RefPtr<GestureEventHub> gestureEventHub_;
642      RefPtr<InputEventHub> inputEventHub_;
643      RefPtr<FocusHub> focusHub_;
644      RefPtr<StateStyleManager> stateStyleMgr_;
645  
646      std::function<void()> onDisappear_;
647      std::function<void()> onJSFrameNodeDisappear_;
648      OnAreaChangedFunc onAreaChanged_;
649      std::unordered_map<int32_t, OnAreaChangedFunc> onAreaChangedInnerCallbacks_;
650      OnSizeChangedFunc onSizeChanged_;
651      std::unordered_map<int32_t, OnSizeChangedFunc> onSizeChangedInnerCallbacks_;
652      OnSizeChangedFunc onJsFrameNodeSizeChanged_;
653  
654      std::function<void()> onAttach_;
655      std::function<void()> onDetach_;
656  
657      OnPreDragFunc onPreDragFunc_;
658      OnDragStartFunc onDragStart_;
659      OnDragFunc onDragEnter_;
660      OnDragFunc onDragLeave_;
661      OnDragFunc onDragMove_;
662      OnDragFunc onDrop_;
663      OnNewDragFunc onDragEnd_;
664  
665      OnDragStartFunc defaultOnDragStart_;
666      OnDragFunc customerOnDragEnter_;
667      OnDragFunc customerOnDragLeave_;
668      OnDragFunc customerOnDragMove_;
669      OnDragFunc customerOnDrop_;
670      OnNewDragFunc customerOnDragEnd_;
671  
672      bool enabled_ { true };
673      bool developerEnabled_ { true };
674      std::vector<KeyboardShortcut> keyboardShortcut_;
675  
676      std::vector<double> visibleAreaUserRatios_;
677      VisibleCallbackInfo visibleAreaUserCallback_;
678      std::vector<double> visibleAreaInnerRatios_;
679      VisibleCallbackInfo visibleAreaInnerCallback_;
680      std::vector<double> throttledVisibleAreaRatios_;
681      VisibleCallbackInfo throttledVisibleAreaCallback_;
682  
683      ACE_DISALLOW_COPY_AND_MOVE(EventHub);
684  };
685  
686  class TextCommonEvent : public BaseEventInfo {
DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent,BaseEventInfo)687      DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent, BaseEventInfo)
688  public:
689      TextCommonEvent() : BaseEventInfo("TextCommonEvent") {}
690      ~TextCommonEvent() override = default;
691  };
692  
693  } // namespace OHOS::Ace::NG
694  
695  #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
696