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_EVENT_CLICK_EVENT_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_CLICK_EVENT_H
18 
19 #include <list>
20 
21 #include "base/memory/ace_type.h"
22 #include "base/memory/referenced.h"
23 #include "base/utils/noncopyable.h"
24 #include "core/components_ng/event/gesture_event_actuator.h"
25 #include "core/components_ng/gestures/recognizers/click_recognizer.h"
26 
27 namespace OHOS::Ace::NG {
28 
29 class GestureEventHub;
30 
31 class ClickEvent : public AceType {
DECLARE_ACE_TYPE(ClickEvent,AceType)32     DECLARE_ACE_TYPE(ClickEvent, AceType)
33 public:
34     explicit ClickEvent(GestureEventFunc&& callback) : callback_(std::move(callback)) {}
35     ~ClickEvent() override = default;
36 
GetGestureEventFunc()37     const GestureEventFunc& GetGestureEventFunc() const
38     {
39         return callback_;
40     }
41 
operator()42     void operator()(GestureEvent& info) const
43     {
44         if (callback_) {
45             callback_(info);
46         }
47     }
48 
SetSysJudge(const GestureJudgeFunc & sysJudge)49     void SetSysJudge(const GestureJudgeFunc& sysJudge)
50     {
51         sysJudge_ = sysJudge;
52     }
53 
HasSysGestureJudge()54     bool HasSysGestureJudge() const
55     {
56         return sysJudge_.has_value();
57     }
58 
GetSysJudge()59     std::optional<GestureJudgeFunc> GetSysJudge() const
60     {
61         if (sysJudge_.has_value()) {
62             return sysJudge_.value();
63         }
64         return nullptr;
65     }
66 
67 private:
68     GestureEventFunc callback_;
69 
70     std::optional<GestureJudgeFunc> sysJudge_ = nullptr;
71 
72     ACE_DISALLOW_COPY_AND_MOVE(ClickEvent);
73 };
74 
75 class ACE_EXPORT ClickEventActuator : public GestureEventActuator {
76     DECLARE_ACE_TYPE(ClickEventActuator, GestureEventActuator)
77 public:
78     explicit ClickEventActuator(const WeakPtr<GestureEventHub>& gestureEventHub);
79     ~ClickEventActuator() override = default;
80 
SetUserCallback(GestureEventFunc && callback)81     void SetUserCallback(GestureEventFunc&& callback)
82     {
83         userCallback_ = MakeRefPtr<ClickEvent>(std::move(callback));
84     }
85 
ClearUserCallback()86     void ClearUserCallback()
87     {
88         // When the event param is undefined, it will clear the callback.
89         if (userCallback_) {
90             userCallback_.Reset();
91         }
92     }
93 
IsUserClickable()94     bool IsUserClickable() const
95     {
96         return userCallback_ != nullptr;
97     }
98 
AddClickEvent(const RefPtr<ClickEvent> & clickEvent)99     void AddClickEvent(const RefPtr<ClickEvent>& clickEvent)
100     {
101         if (clickEvents_.empty()) {
102             clickEvents_.emplace_back(clickEvent);
103             return;
104         }
105         if (std::find(clickEvents_.begin(), clickEvents_.end(), clickEvent) == clickEvents_.end()) {
106             clickEvents_.emplace_back(clickEvent);
107         }
108     }
109 
AddDistanceThreshold(double distanceThreshold)110     void AddDistanceThreshold(double distanceThreshold)
111     {
112         distanceThreshold_ = distanceThreshold;
113         if (LessOrEqual(distanceThreshold_, 0)) {
114             distanceThreshold_ = std::numeric_limits<double>::infinity();
115         }
116     }
117 
RemoveClickEvent(const RefPtr<ClickEvent> & clickEvent)118     void RemoveClickEvent(const RefPtr<ClickEvent>& clickEvent)
119     {
120         clickEvents_.remove(clickEvent);
121     }
122 
IsClickEventsEmpty()123     bool IsClickEventsEmpty() const
124     {
125         return clickEvents_.empty();
126     }
127 
AddClickAfterEvent(const RefPtr<ClickEvent> & clickEvent)128     void AddClickAfterEvent(const RefPtr<ClickEvent>& clickEvent)
129     {
130         clickAfterEvents_ = std::move(clickEvent);
131     }
132 
ClearClickAfterEvent()133     void ClearClickAfterEvent()
134     {
135         // When the event param is undefined, it will clear the callback.
136         if (clickAfterEvents_) {
137             clickAfterEvents_.Reset();
138         }
139     }
140 
141     void OnCollectTouchTarget(const OffsetF& coordinateOffset, const TouchRestrict& touchRestrict,
142         const GetEventTargetImpl& getEventTargetImpl, TouchTestResult& result,
143         ResponseLinkResult& responseLinkResult) override;
144 
145     GestureEventFunc GetClickEvent();
146     std::optional<GestureJudgeFunc> GetSysJudgeFunc() const;
147 
GetClickRecognizer()148     const RefPtr<ClickRecognizer>& GetClickRecognizer()
149     {
150         if (!clickRecognizer_) {
151             clickRecognizer_ = MakeRefPtr<ClickRecognizer>();
152         }
153         return clickRecognizer_;
154     }
155 
SetJSFrameNodeCallback(GestureEventFunc && callback)156     void SetJSFrameNodeCallback(GestureEventFunc&& callback)
157     {
158         if (jsFrameNodeCallback_) {
159             jsFrameNodeCallback_.Reset();
160         }
161         jsFrameNodeCallback_ = MakeRefPtr<ClickEvent>(std::move(callback));
162         if (!clickRecognizer_) {
163             clickRecognizer_ = MakeRefPtr<ClickRecognizer>();
164         }
165     }
166 
ClearJSFrameNodeCallback()167     void ClearJSFrameNodeCallback()
168     {
169         // When the event param is undefined, it will clear the callback.
170         if (jsFrameNodeCallback_) {
171             jsFrameNodeCallback_.Reset();
172         }
173     }
174 
CopyClickEvent(const RefPtr<ClickEventActuator> & clickEventActuator)175     void CopyClickEvent(const RefPtr<ClickEventActuator>& clickEventActuator)
176     {
177         clickEvents_ = clickEventActuator->clickEvents_;
178         userCallback_ = clickEventActuator->userCallback_;
179         jsFrameNodeCallback_ = clickEventActuator->jsFrameNodeCallback_;
180         if (clickEventActuator->clickRecognizer_) {
181             clickRecognizer_ = MakeRefPtr<ClickRecognizer>();
182         }
183     }
184 
185 private:
186     WeakPtr<GestureEventHub> gestureEventHub_;
187     std::list<RefPtr<ClickEvent>> clickEvents_;
188     RefPtr<ClickEvent> clickAfterEvents_;
189     RefPtr<ClickEvent> userCallback_;
190     RefPtr<ClickEvent> jsFrameNodeCallback_;
191     RefPtr<ClickRecognizer> clickRecognizer_;
192     double distanceThreshold_ = std::numeric_limits<double>::infinity();
193 
194     ACE_DISALLOW_COPY_AND_MOVE(ClickEventActuator);
195 };
196 
197 } // namespace OHOS::Ace::NG
198 
199 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_CLICK_EVENT_H
200