• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_GESTURE_RECOGNIZER_H
17 #define FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_GESTURE_RECOGNIZER_H
18 
19 #include <cstdint>
20 
21 #include "base/memory/referenced.h"
22 #include "bridge/declarative_frontend/jsview/js_gesture.h"
23 #include "core/components_ng/gestures/recognizers/gesture_recognizer.h"
24 #include "core/components_ng/pattern/scrollable/scrollable_pattern.h"
25 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
26 #include "core/gestures/gesture_info.h"
27 #include "frameworks/bridge/declarative_frontend/engine/functions/js_function.h"
28 #include "frameworks/core/components_ng/gestures/recognizers/pinch_recognizer.h"
29 #include "frameworks/core/components_ng/gestures/recognizers/rotation_recognizer.h"
30 #include "frameworks/core/components_ng/gestures/recognizers/swipe_recognizer.h"
31 
32 namespace OHOS::Ace::Framework {
33 enum class GestureRecognizerState {
34     UNKNOWN = -1,
35     READY = 0,
36     DETECTING = 1,
37     PENDING = 2,
38     BLOCKED = 3,
39     SUCCEED = 4,
40     FAIL = 5,
41 };
42 
43 class JSEventTargetInfo : public Referenced {
44 public:
45     static void JSBind(BindingTarget globalObj);
46 
SetInspectorId(const std::string & inspectorId)47     void SetInspectorId(const std::string& inspectorId)
48     {
49         inspectorId_ = inspectorId;
50     }
51 
GetInspectorId(const JSCallbackInfo & args)52     void GetInspectorId(const JSCallbackInfo& args)
53     {
54         args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(inspectorId_)));
55     }
56 
57 private:
Constructor(const JSCallbackInfo & args)58     static void Constructor(const JSCallbackInfo& args)
59     {
60         auto jsEventTarget = Referenced::MakeRefPtr<JSEventTargetInfo>();
61         jsEventTarget->IncRefCount();
62         args.SetReturnValue(Referenced::RawPtr(jsEventTarget));
63     }
64 
Destructor(JSEventTargetInfo * jsEventTarget)65     static void Destructor(JSEventTargetInfo* jsEventTarget)
66     {
67         if (jsEventTarget != nullptr) {
68             jsEventTarget->DecRefCount();
69         }
70     }
71 
72     std::string inspectorId_;
73 };
74 
75 class JSScrollableTargetInfo : public JSEventTargetInfo {
76 public:
77     static void JSBind(BindingTarget globalObj);
78 
SetPattern(const WeakPtr<NG::Pattern> & pattern)79     void SetPattern(const WeakPtr<NG::Pattern>& pattern)
80     {
81         pattern_ = pattern;
82     }
83 
84     void IsBegin(const JSCallbackInfo& args);
85 
86     void IsEnd(const JSCallbackInfo& args);
87 
88 private:
Constructor(const JSCallbackInfo & args)89     static void Constructor(const JSCallbackInfo& args)
90     {
91         auto jsScrollableTargetInfo = Referenced::MakeRefPtr<JSScrollableTargetInfo>();
92         jsScrollableTargetInfo->IncRefCount();
93         args.SetReturnValue(Referenced::RawPtr(jsScrollableTargetInfo));
94     }
95 
Destructor(JSScrollableTargetInfo * jsScrollableTargetInfo)96     static void Destructor(JSScrollableTargetInfo* jsScrollableTargetInfo)
97     {
98         if (jsScrollableTargetInfo != nullptr) {
99             jsScrollableTargetInfo->DecRefCount();
100         }
101     }
102 
103     WeakPtr<NG::Pattern> pattern_;
104 };
105 
106 class JSGestureRecognizer : public Referenced {
107 public:
108     static void JSBind(BindingTarget globalObj);
109 
Update(const RefPtr<NG::NGGestureRecognizer> & recognizer)110     void Update(const RefPtr<NG::NGGestureRecognizer>& recognizer)
111     {
112         recognizer_ = recognizer;
113     }
114 
GetRecognizer()115     WeakPtr<NG::NGGestureRecognizer> GetRecognizer()
116     {
117         return recognizer_;
118     }
119 
120     void GetTag(const JSCallbackInfo& args);
121 
122     void GetType(const JSCallbackInfo& args);
123 
124     void GetFingers(const JSCallbackInfo& args);
125 
126     void IsFingerCountLimit(const JSCallbackInfo& args);
127 
128     void IsBuiltInRecognizer(const JSCallbackInfo& args);
129 
130     void SetEnabled(const JSCallbackInfo& args);
131 
132     void IsEnabled(const JSCallbackInfo& args);
133 
134     void GetEventTargetInfo(const JSCallbackInfo& args);
135 
136     void GetRefereeState(const JSCallbackInfo& args);
137 
138     void IsValid(const JSCallbackInfo& args);
139 
ConvertRefereeState(NG::RefereeState state)140     static GestureRecognizerState ConvertRefereeState(NG::RefereeState state)
141     {
142         switch (state) {
143             case NG::RefereeState::READY:
144                 return GestureRecognizerState::READY;
145             case NG::RefereeState::DETECTING:
146                 return GestureRecognizerState::DETECTING;
147             case NG::RefereeState::PENDING:
148                 return GestureRecognizerState::PENDING;
149             case NG::RefereeState::PENDING_BLOCKED:
150             case NG::RefereeState::SUCCEED_BLOCKED:
151                 return GestureRecognizerState::BLOCKED;
152             case NG::RefereeState::SUCCEED:
153                 return GestureRecognizerState::SUCCEED;
154             case NG::RefereeState::FAIL:
155                 return GestureRecognizerState::FAIL;
156             default:
157                 return GestureRecognizerState::UNKNOWN;
158         }
159     }
160 
161 private:
Constructor(const JSCallbackInfo & args)162     static void Constructor(const JSCallbackInfo& args)
163     {
164         auto jsGestureRecognizer = Referenced::MakeRefPtr<JSGestureRecognizer>();
165         jsGestureRecognizer->IncRefCount();
166         args.SetReturnValue(Referenced::RawPtr(jsGestureRecognizer));
167     }
168 
Destructor(JSGestureRecognizer * jsGestureRecognizer)169     static void Destructor(JSGestureRecognizer* jsGestureRecognizer)
170     {
171         if (jsGestureRecognizer != nullptr) {
172             jsGestureRecognizer->DecRefCount();
173         }
174     }
175 
176     WeakPtr<NG::NGGestureRecognizer> recognizer_;
177 
178 protected:
179     bool isLimitFingerCount_ = false;
180     int fingers_ = 1;
181 };
182 
183 class JSMultiFingerRecognizer : public JSGestureRecognizer {
184 public:
Update(const RefPtr<NG::MultiFingersRecognizer> & recognizer)185     void Update(const RefPtr<NG::MultiFingersRecognizer>& recognizer)
186     {
187         JSGestureRecognizer::Update(recognizer);
188         isLimitFingerCount_ = recognizer->GetLimitFingerCount();
189         fingers_ = recognizer->GetFingers();
190     }
191 };
192 
193 class JSPanRecognizer : public JSMultiFingerRecognizer {
194 public:
195     static void JSBind(BindingTarget globalObj);
196 
Update(const RefPtr<NG::PanRecognizer> & recognizer)197     void Update(const RefPtr<NG::PanRecognizer>& recognizer)
198     {
199         JSMultiFingerRecognizer::Update(recognizer);
200         SetPanGestureOptions(
201             recognizer->GetFingers(), recognizer->GetDistance(), recognizer->GetDirection());
202     }
203 
GetPanGestureOptions(const JSCallbackInfo & args)204     void GetPanGestureOptions(const JSCallbackInfo& args)
205     {
206         JSRef<JSObject> panGestureOptionObj = JSClass<JSPanGestureOption>::NewInstance();
207         auto panGestureOption = Referenced::Claim(panGestureOptionObj->Unwrap<JSPanGestureOption>());
208         panGestureOption->SetPanGestureOption(panGestureOption_);
209         args.SetReturnValue(panGestureOptionObj);
210     }
211 
212 private:
Constructor(const JSCallbackInfo & args)213     static void Constructor(const JSCallbackInfo& args)
214     {
215         auto jsPanRecognizer = Referenced::MakeRefPtr<JSPanRecognizer>();
216         jsPanRecognizer->IncRefCount();
217         args.SetReturnValue(Referenced::RawPtr(jsPanRecognizer));
218     }
219 
Destructor(JSPanRecognizer * jsPanRecognizer)220     static void Destructor(JSPanRecognizer* jsPanRecognizer)
221     {
222         if (jsPanRecognizer != nullptr) {
223             jsPanRecognizer->DecRefCount();
224         }
225     }
226 
SetPanGestureOptions(int32_t fingers,double distance,PanDirection direction)227     void SetPanGestureOptions(int32_t fingers, double distance, PanDirection direction)
228     {
229         panGestureOption_ = AceType::MakeRefPtr<PanGestureOption>();
230         panGestureOption_->SetFingers(fingers);
231         panGestureOption_->SetDistance(distance);
232         panGestureOption_->SetDirection(direction);
233     }
234     RefPtr<PanGestureOption> panGestureOption_;
235 };
236 
237 class JSPinchRecognizer : public JSMultiFingerRecognizer {
238 public:
239     static void JSBind(BindingTarget globalObj);
240 
Update(const RefPtr<NG::PinchRecognizer> & recognizer)241     void Update(const RefPtr<NG::PinchRecognizer>& recognizer)
242     {
243         JSMultiFingerRecognizer::Update(recognizer);
244         distance_ = recognizer->GetDistance();
245     }
246 
247     void GetDistance(const JSCallbackInfo& args);
248 
249 private:
Constructor(const JSCallbackInfo & args)250     static void Constructor(const JSCallbackInfo& args)
251     {
252         auto jsPinchRecognizer = Referenced::MakeRefPtr<JSPinchRecognizer>();
253         jsPinchRecognizer->IncRefCount();
254         args.SetReturnValue(Referenced::RawPtr(jsPinchRecognizer));
255     }
256 
Destructor(JSPinchRecognizer * jsPinchRecognizer)257     static void Destructor(JSPinchRecognizer* jsPinchRecognizer)
258     {
259         if (jsPinchRecognizer != nullptr) {
260             jsPinchRecognizer->DecRefCount();
261         }
262     }
263 
264     double distance_ = 5;
265 };
266 
267 class JSTapRecognizer : public JSMultiFingerRecognizer {
268 public:
269     static void JSBind(BindingTarget globalObj);
270 
Update(const RefPtr<NG::ClickRecognizer> & recognizer)271     void Update(const RefPtr<NG::ClickRecognizer>& recognizer)
272     {
273         JSMultiFingerRecognizer::Update(recognizer);
274         count_ = recognizer->GetCount();
275     }
276 
277     void GetCount(const JSCallbackInfo& args);
278 
279 private:
Constructor(const JSCallbackInfo & args)280     static void Constructor(const JSCallbackInfo& args)
281     {
282         auto jsTapRecognizer = Referenced::MakeRefPtr<JSTapRecognizer>();
283         jsTapRecognizer->IncRefCount();
284         args.SetReturnValue(Referenced::RawPtr(jsTapRecognizer));
285     }
286 
Destructor(JSTapRecognizer * jsTapRecognizer)287     static void Destructor(JSTapRecognizer* jsTapRecognizer)
288     {
289         if (jsTapRecognizer != nullptr) {
290             jsTapRecognizer->DecRefCount();
291         }
292     }
293 
294     int32_t count_ = 1;
295 };
296 
297 class JSLongPressRecognizer : public JSMultiFingerRecognizer {
298 public:
299     static void JSBind(BindingTarget globalObj);
300 
Update(const RefPtr<NG::LongPressRecognizer> & recognizer)301     void Update(const RefPtr<NG::LongPressRecognizer>& recognizer)
302     {
303         JSMultiFingerRecognizer::Update(recognizer);
304         duration_ = recognizer->GetDuration();
305         repeat_ = recognizer->GetIsRepeat();
306     }
307 
308     void GetDuration(const JSCallbackInfo& args);
309     void GetRepeat(const JSCallbackInfo& args);
310     void SetRepeat(bool repeat);
311 
312 private:
Constructor(const JSCallbackInfo & args)313     static void Constructor(const JSCallbackInfo& args)
314     {
315         auto jsLongPressRecognizer = Referenced::MakeRefPtr<JSLongPressRecognizer>();
316         jsLongPressRecognizer->IncRefCount();
317         args.SetReturnValue(Referenced::RawPtr(jsLongPressRecognizer));
318     }
319 
Destructor(JSLongPressRecognizer * jsLongPressRecognizer)320     static void Destructor(JSLongPressRecognizer* jsLongPressRecognizer)
321     {
322         if (jsLongPressRecognizer != nullptr) {
323             jsLongPressRecognizer->DecRefCount();
324         }
325     }
326 
327     int32_t duration_ = 500;
328     bool repeat_ = false;
329 };
330 
331 class JSRotationRecognizer : public JSMultiFingerRecognizer {
332 public:
333     static void JSBind(BindingTarget globalObj);
334 
Update(const RefPtr<NG::RotationRecognizer> & recognizer)335     void Update(const RefPtr<NG::RotationRecognizer>& recognizer)
336     {
337         JSMultiFingerRecognizer::Update(recognizer);
338         angle_ = recognizer->GetAngle();
339     }
340 
341     void GetAngle(const JSCallbackInfo& args);
342 
343 private:
Constructor(const JSCallbackInfo & args)344     static void Constructor(const JSCallbackInfo& args)
345     {
346         auto jsRotationRecognizer = Referenced::MakeRefPtr<JSRotationRecognizer>();
347         jsRotationRecognizer->IncRefCount();
348         args.SetReturnValue(Referenced::RawPtr(jsRotationRecognizer));
349     }
350 
Destructor(JSRotationRecognizer * jsRotationRecognizer)351     static void Destructor(JSRotationRecognizer* jsRotationRecognizer)
352     {
353         if (jsRotationRecognizer != nullptr) {
354             jsRotationRecognizer->DecRefCount();
355         }
356     }
357 
358     double angle_ = 1.0;
359 };
360 
361 class JSSwipeRecognizer : public JSMultiFingerRecognizer {
362 public:
363     static void JSBind(BindingTarget globalObj);
364 
Update(const RefPtr<NG::SwipeRecognizer> & recognizer)365     void Update(const RefPtr<NG::SwipeRecognizer>& recognizer)
366     {
367         JSMultiFingerRecognizer::Update(recognizer);
368         direction_ = recognizer->GetDirection();
369         speed_ = recognizer->GetSpeed();
370     }
371 
372     void GetDirection(const JSCallbackInfo& args);
373     void GetSpeed(const JSCallbackInfo& args);
374 
375 private:
Constructor(const JSCallbackInfo & args)376     static void Constructor(const JSCallbackInfo& args)
377     {
378         auto jsSwipeRecognizer = Referenced::MakeRefPtr<JSSwipeRecognizer>();
379         jsSwipeRecognizer->IncRefCount();
380         args.SetReturnValue(Referenced::RawPtr(jsSwipeRecognizer));
381     }
382 
Destructor(JSSwipeRecognizer * jsSwipeRecognizer)383     static void Destructor(JSSwipeRecognizer* jsSwipeRecognizer)
384     {
385         if (jsSwipeRecognizer != nullptr) {
386             jsSwipeRecognizer->DecRefCount();
387         }
388     }
389 
390     SwipeDirection direction_;
391     double speed_ = 100.0;
392 };
393 } // namespace OHOS::Ace::Framework
394 #endif // FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_GESTURE_RECOGNIZER_H