1 /*
2  * Copyright (c) 2021-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 #include "frameworks/bridge/declarative_frontend/jsview/js_gesture.h"
17 
18 #include "base/log/log_wrapper.h"
19 #include "bridge/declarative_frontend/jsview/models/gesture_model_impl.h"
20 #include "core/components_ng/pattern/gesture/gesture_model_ng.h"
21 #include "frameworks/base/log/ace_scoring_log.h"
22 #include "frameworks/bridge/declarative_frontend/engine/functions/js_gesture_function.h"
23 #include "frameworks/core/gestures/timeout_gesture.h"
24 
25 namespace OHOS::Ace {
26 std::unique_ptr<GestureModel> GestureModel::instance_ = nullptr;
27 std::mutex GestureModel::mutex_;
GetInstance()28 GestureModel* GestureModel::GetInstance()
29 {
30     if (!instance_) {
31         std::lock_guard<std::mutex> lock(mutex_);
32         if (!instance_) {
33 #ifdef NG_BUILD
34             instance_.reset(new NG::GestureModelNG());
35 #else
36             if (Container::IsCurrentUseNewPipeline()) {
37                 instance_.reset(new NG::GestureModelNG());
38             } else {
39                 instance_.reset(new Framework::GestureModelImpl());
40             }
41 #endif
42         }
43     }
44     return instance_.get();
45 }
46 
47 std::unique_ptr<TapGestureModel> TapGestureModel::instance_ = nullptr;
48 std::mutex TapGestureModel::mutex_;
GetInstance()49 TapGestureModel* TapGestureModel::GetInstance()
50 {
51     if (!instance_) {
52         std::lock_guard<std::mutex> lock(mutex_);
53         if (!instance_) {
54 #ifdef NG_BUILD
55             instance_.reset(new NG::TapGestureModelNG());
56 #else
57             if (Container::IsCurrentUseNewPipeline()) {
58                 instance_.reset(new NG::TapGestureModelNG());
59             } else {
60                 instance_.reset(new Framework::TapGestureModelImpl());
61             }
62 #endif
63         }
64     }
65     return instance_.get();
66 }
67 
68 std::unique_ptr<LongPressGestureModel> LongPressGestureModel::instance_ = nullptr;
69 std::mutex LongPressGestureModel::mutex_;
GetInstance()70 LongPressGestureModel* LongPressGestureModel::GetInstance()
71 {
72     if (!instance_) {
73         std::lock_guard<std::mutex> lock(mutex_);
74         if (!instance_) {
75 #ifdef NG_BUILD
76             instance_.reset(new NG::LongPressGestureModelNG());
77 #else
78             if (Container::IsCurrentUseNewPipeline()) {
79                 instance_.reset(new NG::LongPressGestureModelNG());
80             } else {
81                 instance_.reset(new Framework::LongPressGestureModelImpl());
82             }
83 #endif
84         }
85     }
86     return instance_.get();
87 }
88 
89 std::unique_ptr<PanGestureModel> PanGestureModel::instance_ = nullptr;
90 std::mutex PanGestureModel::mutex_;
GetInstance()91 PanGestureModel* PanGestureModel::GetInstance()
92 {
93     if (!instance_) {
94         std::lock_guard<std::mutex> lock(mutex_);
95         if (!instance_) {
96 #ifdef NG_BUILD
97             instance_.reset(new NG::PanGestureModelNG());
98 #else
99             if (Container::IsCurrentUseNewPipeline()) {
100                 instance_.reset(new NG::PanGestureModelNG());
101             } else {
102                 instance_.reset(new Framework::PanGestureModelImpl());
103             }
104 #endif
105         }
106     }
107     return instance_.get();
108 }
109 
110 std::unique_ptr<SwipeGestureModel> SwipeGestureModel::instance_ = nullptr;
111 std::mutex SwipeGestureModel::mutex_;
GetInstance()112 SwipeGestureModel* SwipeGestureModel::GetInstance()
113 {
114     if (!instance_) {
115         std::lock_guard<std::mutex> lock(mutex_);
116         if (!instance_) {
117 #ifdef NG_BUILD
118             instance_.reset(new NG::SwipeGestureModelNG());
119 #else
120             if (Container::IsCurrentUseNewPipeline()) {
121                 instance_.reset(new NG::SwipeGestureModelNG());
122             } else {
123                 instance_.reset(new Framework::SwipeGestureModelImpl());
124             }
125 #endif
126         }
127     }
128     return instance_.get();
129 }
130 
131 std::unique_ptr<PinchGestureModel> PinchGestureModel::instance_ = nullptr;
132 std::mutex PinchGestureModel::mutex_;
GetInstance()133 PinchGestureModel* PinchGestureModel::GetInstance()
134 {
135     if (!instance_) {
136         std::lock_guard<std::mutex> lock(mutex_);
137         if (!instance_) {
138 #ifdef NG_BUILD
139             instance_.reset(new NG::PinchGestureModelNG());
140 #else
141             if (Container::IsCurrentUseNewPipeline()) {
142                 instance_.reset(new NG::PinchGestureModelNG());
143             } else {
144                 instance_.reset(new Framework::PinchGestureModelImpl());
145             }
146 #endif
147         }
148     }
149     return instance_.get();
150 }
151 
152 std::unique_ptr<RotationGestureModel> RotationGestureModel::instance_ = nullptr;
153 std::mutex RotationGestureModel::mutex_;
GetInstance()154 RotationGestureModel* RotationGestureModel::GetInstance()
155 {
156     if (!instance_) {
157         std::lock_guard<std::mutex> lock(mutex_);
158         if (!instance_) {
159 #ifdef NG_BUILD
160             instance_.reset(new NG::RotationGestureModelNG());
161 #else
162             if (Container::IsCurrentUseNewPipeline()) {
163                 instance_.reset(new NG::RotationGestureModelNG());
164             } else {
165                 instance_.reset(new Framework::RotationGestureModelImpl());
166             }
167 #endif
168         }
169     }
170     return instance_.get();
171 }
172 
173 std::unique_ptr<GestureGroupModel> GestureGroupModel::instance_ = nullptr;
174 std::mutex GestureGroupModel::mutex_;
GetInstance()175 GestureGroupModel* GestureGroupModel::GetInstance()
176 {
177     if (!instance_) {
178         std::lock_guard<std::mutex> lock(mutex_);
179         if (!instance_) {
180 #ifdef NG_BUILD
181             instance_.reset(new NG::GestureGroupModelNG());
182 #else
183             if (Container::IsCurrentUseNewPipeline()) {
184                 instance_.reset(new NG::GestureGroupModelNG());
185             } else {
186                 instance_.reset(new Framework::GestureGroupModelImpl());
187             }
188 #endif
189         }
190     }
191     return instance_.get();
192 }
193 
194 std::unique_ptr<TimeoutGestureModel> TimeoutGestureModel::instance_ = nullptr;
195 std::mutex TimeoutGestureModel::mutex_;
GetInstance()196 TimeoutGestureModel* TimeoutGestureModel::GetInstance()
197 {
198     if (!instance_) {
199         std::lock_guard<std::mutex> lock(mutex_);
200         if (!instance_) {
201 #ifdef NG_BUILD
202             instance_.reset(new NG::TimeoutGestureModelNG());
203 #else
204             if (Container::IsCurrentUseNewPipeline()) {
205                 instance_.reset(new NG::TimeoutGestureModelNG());
206             } else {
207                 instance_.reset(new Framework::TimeoutGestureModelImpl());
208             }
209 #endif
210         }
211     }
212     return instance_.get();
213 }
214 } // namespace OHOS::Ace
215 
216 namespace OHOS::Ace::Framework {
217 namespace {
218 constexpr int32_t DEFAULT_TAP_FINGER = 1;
219 constexpr int32_t DEFAULT_TAP_COUNT = 1;
220 constexpr double DEFAULT_TAP_DISTANCE = std::numeric_limits<double>::infinity();
221 constexpr int32_t DEFAULT_LONG_PRESS_FINGER = 1;
222 constexpr int32_t DEFAULT_LONG_PRESS_DURATION = 500;
223 constexpr int32_t DEFAULT_PINCH_FINGER = 2;
224 constexpr int32_t DEFAULT_MAX_PINCH_FINGER = 5;
225 constexpr double DEFAULT_PINCH_DISTANCE = 5.0;
226 constexpr int32_t DEFAULT_PAN_FINGER = 1;
227 constexpr int32_t DEFAULT_MAX_PAN_FINGERS = 10;
228 constexpr Dimension DEFAULT_PAN_DISTANCE = 5.0_vp;
229 constexpr int32_t DEFAULT_SLIDE_FINGER = DEFAULT_PAN_FINGER;
230 constexpr double DEFAULT_SLIDE_SPEED = 100.0;
231 constexpr int32_t DEFAULT_ROTATION_FINGER = 2;
232 constexpr double DEFAULT_ROTATION_ANGLE = 1.0;
233 
234 constexpr char GESTURE_FINGERS[] = "fingers";
235 constexpr char GESTURE_DISTANCE[] = "distance";
236 constexpr char TAP_GESTURE_DISTANCE[] = "distanceThreshold";
237 constexpr char GESTURE_SPEED[] = "speed";
238 constexpr char TAP_COUNT[] = "count";
239 constexpr char LONG_PRESS_REPEAT[] = "repeat";
240 constexpr char LONG_PRESS_DURATION[] = "duration";
241 constexpr char PAN_DIRECTION[] = "direction";
242 constexpr char SWIPE_DIRECTION[] = "direction";
243 constexpr char ROTATION_ANGLE[] = "angle";
244 } // namespace
245 
Create(const JSCallbackInfo & info)246 void JSGesture::Create(const JSCallbackInfo& info)
247 {
248     int32_t priorityNum = 0;
249     if (info.Length() > 0) {
250         auto jsPriorityNum = info[0];
251         if (jsPriorityNum->IsNumber()) {
252             priorityNum = jsPriorityNum->ToNumber<int32_t>();
253         }
254     }
255 
256     int32_t gestureMaskNum = 0;
257     if (info.Length() > 1) {
258         auto jsGestureMaskNum = info[1];
259         if (jsGestureMaskNum->IsNumber()) {
260             gestureMaskNum = jsGestureMaskNum->ToNumber<int32_t>();
261         }
262     }
263 
264     GestureModel::GetInstance()->Create(priorityNum, gestureMaskNum);
265 }
266 
Finish()267 void JSGesture::Finish()
268 {
269     GestureModel::GetInstance()->Finish();
270 }
271 
Pop()272 void JSGesture::Pop()
273 {
274     GestureModel::GetInstance()->Pop();
275 }
276 
Create(const JSCallbackInfo & args)277 void JSTapGesture::Create(const JSCallbackInfo& args)
278 {
279     int32_t countNum = DEFAULT_TAP_COUNT;
280     int32_t fingersNum = DEFAULT_TAP_FINGER;
281     double distanceThresholdNum = DEFAULT_TAP_DISTANCE;
282     if (args.Length() > 0 && args[0]->IsObject()) {
283         JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
284         JSRef<JSVal> count = obj->GetProperty(TAP_COUNT);
285         JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
286         JSRef<JSVal> distanceThreshold = obj->GetProperty(TAP_GESTURE_DISTANCE);
287 
288         if (count->IsNumber()) {
289             int32_t countNumber = count->ToNumber<int32_t>();
290             countNum = countNumber <= DEFAULT_TAP_COUNT ? DEFAULT_TAP_COUNT : countNumber;
291         }
292         if (fingers->IsNumber()) {
293             int32_t fingersNumber = fingers->ToNumber<int32_t>();
294             fingersNum = fingersNumber <= DEFAULT_TAP_FINGER ? DEFAULT_TAP_FINGER : fingersNumber;
295         }
296         if (distanceThreshold->IsNumber()) {
297             double distanceThresholdNumber = distanceThreshold->ToNumber<double>();
298             distanceThresholdNum = distanceThresholdNumber < 0? DEFAULT_TAP_DISTANCE : distanceThresholdNumber;
299             distanceThresholdNum = Dimension(distanceThresholdNum, DimensionUnit::VP).ConvertToPx();
300         }
301     }
302 
303     TapGestureModel::GetInstance()->Create(countNum, fingersNum, distanceThresholdNum);
304 }
305 
Create(const JSCallbackInfo & args)306 void JSLongPressGesture::Create(const JSCallbackInfo& args)
307 {
308     int32_t fingersNum = DEFAULT_LONG_PRESS_FINGER;
309     bool repeatResult = false;
310     int32_t durationNum = DEFAULT_LONG_PRESS_DURATION;
311     if (args.Length() > 0 && args[0]->IsObject()) {
312         JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
313         JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
314         JSRef<JSVal> repeat = obj->GetProperty(LONG_PRESS_REPEAT);
315         JSRef<JSVal> duration = obj->GetProperty(LONG_PRESS_DURATION);
316 
317         if (fingers->IsNumber()) {
318             int32_t fingersNumber = fingers->ToNumber<int32_t>();
319             fingersNum = fingersNumber <= DEFAULT_LONG_PRESS_FINGER ? DEFAULT_LONG_PRESS_FINGER : fingersNumber;
320         }
321         if (repeat->IsBoolean()) {
322             repeatResult = repeat->ToBoolean();
323         }
324         if (duration->IsNumber()) {
325             int32_t durationNumber = duration->ToNumber<int32_t>();
326             durationNum = durationNumber <= 0 ? DEFAULT_LONG_PRESS_DURATION : durationNumber;
327         }
328     }
329 
330     LongPressGestureModel::GetInstance()->Create(fingersNum, repeatResult, durationNum);
331 }
332 
Create(const JSCallbackInfo & args)333 void JSPanGesture::Create(const JSCallbackInfo& args)
334 {
335     int32_t fingersNum = DEFAULT_PAN_FINGER;
336     double distanceNum = DEFAULT_PAN_DISTANCE.ConvertToPx();
337     PanDirection panDirection;
338     if (args.Length() <= 0 || !args[0]->IsObject()) {
339         PanGestureModel::GetInstance()->Create(fingersNum, panDirection, distanceNum);
340         return;
341     }
342 
343     JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
344     JSPanGestureOption* panGestureOption = obj->Unwrap<JSPanGestureOption>();
345 
346     if (panGestureOption != nullptr) {
347         RefPtr<PanGestureOption> refPanGestureOption = panGestureOption->GetPanGestureOption();
348         PanGestureModel::GetInstance()->SetPanGestureOption(refPanGestureOption);
349         return;
350     }
351 
352     JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
353     JSRef<JSVal> distance = obj->GetProperty(GESTURE_DISTANCE);
354     JSRef<JSVal> directionNum = obj->GetProperty(PAN_DIRECTION);
355 
356     if (fingers->IsNumber()) {
357         int32_t fingersNumber = fingers->ToNumber<int32_t>();
358         fingersNum = fingersNumber <= DEFAULT_PAN_FINGER ? DEFAULT_PAN_FINGER : fingersNumber;
359     }
360     if (distance->IsNumber()) {
361         double distanceNumber = distance->ToNumber<double>();
362         Dimension dimension =
363             LessNotEqual(distanceNumber, 0.0) ? DEFAULT_PAN_DISTANCE : Dimension(distanceNumber, DimensionUnit::VP);
364         distanceNum = dimension.ConvertToPx();
365     }
366     if (directionNum->IsNumber()) {
367         uint32_t directNum = directionNum->ToNumber<uint32_t>();
368         if (directNum >= static_cast<uint32_t>(PanDirection::NONE) &&
369             directNum <= static_cast<uint32_t>(PanDirection::ALL)) {
370             panDirection.type = directNum;
371         }
372     }
373 
374     PanGestureModel::GetInstance()->Create(fingersNum, panDirection, distanceNum);
375 }
376 
Create(const JSCallbackInfo & args)377 void JSSwipeGesture::Create(const JSCallbackInfo& args)
378 {
379     int32_t fingersNum = DEFAULT_SLIDE_FINGER;
380     double speedNum = DEFAULT_SLIDE_SPEED;
381     SwipeDirection slideDirection;
382 
383     if (args.Length() <= 0 || !args[0]->IsObject()) {
384         SwipeGestureModel::GetInstance()->Create(fingersNum, slideDirection, speedNum);
385         return;
386     }
387 
388     JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
389     JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
390     JSRef<JSVal> speed = obj->GetProperty(GESTURE_SPEED);
391     JSRef<JSVal> directionNum = obj->GetProperty(SWIPE_DIRECTION);
392 
393     if (fingers->IsNumber()) {
394         int32_t fingersNumber = fingers->ToNumber<int32_t>();
395         fingersNum = fingersNumber <= DEFAULT_PAN_FINGER ? DEFAULT_PAN_FINGER : fingersNumber;
396     }
397     if (speed->IsNumber()) {
398         double speedNumber = speed->ToNumber<double>();
399         speedNum = LessOrEqual(speedNumber, 0.0) ? DEFAULT_SLIDE_SPEED : speedNumber;
400     }
401     if (directionNum->IsNumber()) {
402         uint32_t directNum = directionNum->ToNumber<uint32_t>();
403         if (directNum >= static_cast<uint32_t>(SwipeDirection::NONE) &&
404             directNum <= static_cast<uint32_t>(SwipeDirection::ALL)) {
405             slideDirection.type = directNum;
406         }
407     }
408 
409     SwipeGestureModel::GetInstance()->Create(fingersNum, slideDirection, speedNum);
410 }
411 
Create(const JSCallbackInfo & args)412 void JSPinchGesture::Create(const JSCallbackInfo& args)
413 {
414     int32_t fingersNum = DEFAULT_PINCH_FINGER;
415     double distanceNum = DEFAULT_PINCH_DISTANCE;
416     if (args.Length() > 0 && args[0]->IsObject()) {
417         JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
418         JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
419         JSRef<JSVal> distance = obj->GetProperty(GESTURE_DISTANCE);
420 
421         if (fingers->IsNumber()) {
422             int32_t fingersNumber = fingers->ToNumber<int32_t>();
423             fingersNum = fingersNumber <= DEFAULT_PINCH_FINGER ? DEFAULT_PINCH_FINGER : fingersNumber;
424             fingersNum = fingersNum > DEFAULT_MAX_PINCH_FINGER ? DEFAULT_PINCH_FINGER : fingersNum;
425         }
426         if (distance->IsNumber()) {
427             double distanceNumber = distance->ToNumber<double>();
428             distanceNum = LessNotEqual(distanceNumber, 0.0) ? DEFAULT_PINCH_DISTANCE : distanceNumber;
429         }
430     }
431 
432     PinchGestureModel::GetInstance()->Create(fingersNum, distanceNum);
433 }
434 
Create(const JSCallbackInfo & args)435 void JSRotationGesture::Create(const JSCallbackInfo& args)
436 {
437     double angleNum = DEFAULT_ROTATION_ANGLE;
438     int32_t fingersNum = DEFAULT_ROTATION_FINGER;
439     if (args.Length() > 0 && args[0]->IsObject()) {
440         JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
441         JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
442         JSRef<JSVal> angle = obj->GetProperty(ROTATION_ANGLE);
443 
444         if (fingers->IsNumber()) {
445             int32_t fingersNumber = fingers->ToNumber<int32_t>();
446             fingersNum = fingersNumber <= DEFAULT_ROTATION_FINGER ? DEFAULT_ROTATION_FINGER : fingersNumber;
447         }
448         if (angle->IsNumber()) {
449             double angleNumber = angle->ToNumber<double>();
450             angleNum = LessNotEqual(angleNumber, 0.0) ? DEFAULT_ROTATION_ANGLE : angleNumber;
451         }
452     }
453 
454     RotationGestureModel::GetInstance()->Create(fingersNum, angleNum);
455 }
456 
Create(const JSCallbackInfo & args)457 void JSGestureGroup::Create(const JSCallbackInfo& args)
458 {
459     int32_t gestureMode = 0;
460     if (args.Length() > 0) {
461         auto jsGestureMode = args[0];
462         if (jsGestureMode->IsNumber()) {
463             gestureMode = jsGestureMode->ToNumber<int32_t>();
464         }
465     }
466 
467     GestureGroupModel::GetInstance()->Create(gestureMode);
468 }
469 
JsHandlerOnGestureEvent(Ace::GestureEventAction action,const JSCallbackInfo & args)470 void JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction action, const JSCallbackInfo& args)
471 {
472     if (args.Length() < 1 || !args[0]->IsFunction()) {
473         return;
474     }
475 
476     RefPtr<JsGestureFunction> handlerFunc = AceType::MakeRefPtr<JsGestureFunction>(JSRef<JSFunc>::Cast(args[0]));
477 
478     if (action == Ace::GestureEventAction::CANCEL) {
479         auto onActionCancelFunc = [execCtx = args.GetExecutionContext(), func = std::move(handlerFunc)]() {
480             JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
481             auto info = GestureEvent();
482             ACE_SCORING_EVENT("Gesture.onCancel");
483             func->Execute(info);
484         };
485         GestureModel::GetInstance()->SetOnGestureEvent(onActionCancelFunc);
486         return;
487     }
488 
489     auto onActionFunc = [execCtx = args.GetExecutionContext(), func = std::move(handlerFunc)](GestureEvent& info) {
490         JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx);
491         ACE_SCORING_EVENT("Gesture.onActionCancel");
492         func->Execute(info);
493     };
494 
495     GestureModel::GetInstance()->SetOnActionFunc(onActionFunc, action);
496 }
497 
SetTag(const JSCallbackInfo & args)498 void JSGesture::SetTag(const JSCallbackInfo& args)
499 {
500     std::string tag;
501     if (args.Length() > 0) {
502         auto jsTag = args[0];
503         if (jsTag->IsString()) {
504             tag = jsTag->ToString();
505         }
506     }
507     GestureModel::GetInstance()->SetTag(tag);
508 }
509 
SetAllowedTypes(const JSCallbackInfo & args)510 void JSGesture::SetAllowedTypes(const JSCallbackInfo& args)
511 {
512     if (args.Length() < 1) {
513         return;
514     }
515 
516     JSRef<JSVal> jsTypes = args[0];
517     if (!jsTypes->IsArray()) {
518         return;
519     }
520     JSRef<JSArray> jsTypesArr = JSRef<JSArray>::Cast(jsTypes);
521     std::set<SourceTool> allowedTypes{};
522     auto typesArrLength = jsTypesArr->Length();
523     for (size_t i = 0; i < typesArrLength; ++i) {
524         auto type = jsTypesArr->GetValueAt(i);
525         if (type->IsNumber()) {
526             allowedTypes.insert(static_cast<SourceTool>(type->ToNumber<int32_t>()));
527         }
528     }
529     if (allowedTypes.empty()) {
530         return;
531     }
532     GestureModel::GetInstance()->SetAllowedTypes(allowedTypes);
533 }
534 
JsHandlerOnAction(const JSCallbackInfo & args)535 void JSGesture::JsHandlerOnAction(const JSCallbackInfo& args)
536 {
537     JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction::ACTION, args);
538 }
JsHandlerOnActionStart(const JSCallbackInfo & args)539 void JSGesture::JsHandlerOnActionStart(const JSCallbackInfo& args)
540 {
541     JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction::START, args);
542 }
JsHandlerOnActionUpdate(const JSCallbackInfo & args)543 void JSGesture::JsHandlerOnActionUpdate(const JSCallbackInfo& args)
544 {
545     JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction::UPDATE, args);
546 }
547 
JsHandlerOnActionEnd(const JSCallbackInfo & args)548 void JSGesture::JsHandlerOnActionEnd(const JSCallbackInfo& args)
549 {
550     JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction::END, args);
551 }
JsHandlerOnActionCancel(const JSCallbackInfo & args)552 void JSGesture::JsHandlerOnActionCancel(const JSCallbackInfo& args)
553 {
554     JSGesture::JsHandlerOnGestureEvent(Ace::GestureEventAction::CANCEL, args);
555 }
556 
JSBind(BindingTarget globalObj)557 void JSPanGestureOption::JSBind(BindingTarget globalObj)
558 {
559     JSClass<JSPanGestureOption>::Declare("PanGestureOption");
560     JSClass<JSPanGestureOption>::CustomMethod("setDirection", &JSPanGestureOption::SetDirection);
561     JSClass<JSPanGestureOption>::CustomMethod("setDistance", &JSPanGestureOption::SetDistance);
562     JSClass<JSPanGestureOption>::CustomMethod("setFingers", &JSPanGestureOption::SetFingers);
563     JSClass<JSPanGestureOption>::Bind(globalObj, &JSPanGestureOption::Constructor, &JSPanGestureOption::Destructor);
564 
565     JSClass<JSPanGestureOption>::Declare("PanGestureOptions");
566     JSClass<JSPanGestureOption>::CustomMethod("setDirection", &JSPanGestureOption::SetDirection);
567     JSClass<JSPanGestureOption>::CustomMethod("setDistance", &JSPanGestureOption::SetDistance);
568     JSClass<JSPanGestureOption>::CustomMethod("setFingers", &JSPanGestureOption::SetFingers);
569     JSClass<JSPanGestureOption>::CustomMethod("getDirection", &JSPanGestureOption::GetDirection);
570     JSClass<JSPanGestureOption>::Bind(globalObj, &JSPanGestureOption::Constructor, &JSPanGestureOption::Destructor);
571 }
572 
SetDirection(const JSCallbackInfo & args)573 void JSPanGestureOption::SetDirection(const JSCallbackInfo& args)
574 {
575     if (args.Length() > 0 && args[0]->IsNumber()) {
576         PanDirection direction = { args[0]->ToNumber<int32_t>() };
577         panGestureOption_->SetDirection(direction);
578     } else {
579         PanDirection directionAll = { PanDirection::ALL };
580         panGestureOption_->SetDirection(directionAll);
581     }
582 }
583 
SetDistance(const JSCallbackInfo & args)584 void JSPanGestureOption::SetDistance(const JSCallbackInfo& args)
585 {
586     if (args.Length() > 0 && args[0]->IsNumber()) {
587         auto distance = args[0]->ToNumber<double>();
588         Dimension dimension =
589             LessNotEqual(distance, 0.0) ? DEFAULT_PAN_DISTANCE : Dimension(distance, DimensionUnit::VP);
590         panGestureOption_->SetDistance(dimension.ConvertToPx());
591     } else {
592         panGestureOption_->SetDistance(DEFAULT_PAN_DISTANCE.ConvertToPx());
593     }
594 }
595 
SetFingers(const JSCallbackInfo & args)596 void JSPanGestureOption::SetFingers(const JSCallbackInfo& args)
597 {
598     if (args.Length() > 0 && args[0]->IsNumber()) {
599         auto fingers = args[0]->ToNumber<int32_t>();
600         fingers = fingers <= DEFAULT_PAN_FINGER ? DEFAULT_PAN_FINGER : fingers;
601         fingers = fingers > DEFAULT_MAX_PAN_FINGERS ? DEFAULT_PAN_FINGER : fingers;
602         panGestureOption_->SetFingers(fingers);
603     } else {
604         panGestureOption_->SetFingers(DEFAULT_PAN_FINGER);
605     }
606 }
607 
GetDirection(const JSCallbackInfo & args)608 void JSPanGestureOption::GetDirection(const JSCallbackInfo& args)
609 {
610     PanDirection direction = { PanDirection::NONE };
611     if (panGestureOption_) {
612         direction = panGestureOption_->GetDirection();
613     }
614     args.SetReturnValue(JSRef<JSVal>::Make(ToJSValue(static_cast<int32_t>(direction.type))));
615 }
616 
Constructor(const JSCallbackInfo & args)617 void JSPanGestureOption::Constructor(const JSCallbackInfo& args)
618 {
619     auto panGestureOption = Referenced::MakeRefPtr<JSPanGestureOption>();
620     panGestureOption->IncRefCount();
621     RefPtr<PanGestureOption> option = AceType::MakeRefPtr<PanGestureOption>();
622 
623     int32_t fingersNum = DEFAULT_PAN_FINGER;
624     double distanceNum = DEFAULT_PAN_DISTANCE.ConvertToPx();
625     PanDirection panDirection;
626 
627     if (args.Length() > 0 && args[0]->IsObject()) {
628         JSRef<JSObject> obj = JSRef<JSObject>::Cast(args[0]);
629         JSRef<JSVal> fingers = obj->GetProperty(GESTURE_FINGERS);
630         JSRef<JSVal> distance = obj->GetProperty(GESTURE_DISTANCE);
631         JSRef<JSVal> directionNum = obj->GetProperty(PAN_DIRECTION);
632 
633         if (fingers->IsNumber()) {
634             int32_t fingersNumber = fingers->ToNumber<int32_t>();
635             fingersNum = fingersNumber <= DEFAULT_PAN_FINGER ? DEFAULT_PAN_FINGER : fingersNumber;
636         }
637         if (distance->IsNumber()) {
638             double distanceNumber = distance->ToNumber<double>();
639             Dimension dimension =
640                 LessNotEqual(distanceNumber, 0.0) ? DEFAULT_PAN_DISTANCE : Dimension(distanceNumber, DimensionUnit::VP);
641             distanceNum = dimension.ConvertToPx();
642         }
643         if (directionNum->IsNumber()) {
644             uint32_t directNum = directionNum->ToNumber<uint32_t>();
645             if (directNum >= static_cast<uint32_t>(PanDirection::NONE) &&
646                 directNum <= static_cast<uint32_t>(PanDirection::ALL)) {
647                 panDirection.type = directNum;
648             }
649         }
650     }
651     option->SetDirection(panDirection);
652     option->SetDistance(distanceNum);
653     option->SetFingers(fingersNum);
654 
655     panGestureOption->SetPanGestureOption(option);
656     args.SetReturnValue(Referenced::RawPtr(panGestureOption));
657 }
658 
Destructor(JSPanGestureOption * panGestureOption)659 void JSPanGestureOption::Destructor(JSPanGestureOption* panGestureOption)
660 {
661     if (panGestureOption != nullptr) {
662         panGestureOption->DecRefCount();
663     }
664 }
665 
JSBind(BindingTarget globalObj)666 void JSGesture::JSBind(BindingTarget globalObj)
667 {
668     JSClass<JSGesture>::Declare("Gesture");
669     MethodOptions opt = MethodOptions::NONE;
670     JSClass<JSGesture>::StaticMethod("create", &JSGesture::Create, opt);
671     JSClass<JSGesture>::StaticMethod("pop", &JSGesture::Finish);
672     JSClass<JSGesture>::Bind<>(globalObj);
673 
674     JSClass<JSTapGesture>::Declare("TapGesture");
675     JSClass<JSTapGesture>::StaticMethod("create", &JSTapGesture::Create, opt);
676     JSClass<JSTapGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
677     JSClass<JSTapGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
678     JSClass<JSTapGesture>::StaticMethod("pop", &JSGesture::Pop);
679     JSClass<JSTapGesture>::StaticMethod("onAction", &JSGesture::JsHandlerOnAction);
680     JSClass<JSTapGesture>::StaticMethod("onActionUpdate", &JSGesture::JsHandlerOnActionUpdate);
681     JSClass<JSTapGesture>::Bind<>(globalObj);
682 
683     JSClass<JSLongPressGesture>::Declare("LongPressGesture");
684     JSClass<JSLongPressGesture>::StaticMethod("create", &JSLongPressGesture::Create, opt);
685     JSClass<JSLongPressGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
686     JSClass<JSLongPressGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
687     JSClass<JSLongPressGesture>::StaticMethod("pop", &JSGesture::Pop);
688     JSClass<JSLongPressGesture>::StaticMethod("onAction", &JSGesture::JsHandlerOnAction);
689     JSClass<JSLongPressGesture>::StaticMethod("onActionEnd", &JSGesture::JsHandlerOnActionEnd);
690     JSClass<JSLongPressGesture>::StaticMethod("onActionCancel", &JSGesture::JsHandlerOnActionCancel);
691     JSClass<JSLongPressGesture>::StaticMethod("onActionUpdate", &JSGesture::JsHandlerOnActionUpdate);
692     JSClass<JSLongPressGesture>::Bind(globalObj);
693 
694     JSClass<JSPanGesture>::Declare("PanGesture");
695     JSClass<JSPanGesture>::StaticMethod("create", &JSPanGesture::Create, opt);
696     JSClass<JSPanGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
697     JSClass<JSPanGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
698     JSClass<JSPanGesture>::StaticMethod("pop", &JSGesture::Pop);
699     JSClass<JSPanGesture>::StaticMethod("onActionStart", &JSGesture::JsHandlerOnActionStart);
700     JSClass<JSPanGesture>::StaticMethod("onActionUpdate", &JSGesture::JsHandlerOnActionUpdate);
701     JSClass<JSPanGesture>::StaticMethod("onActionEnd", &JSGesture::JsHandlerOnActionEnd);
702     JSClass<JSPanGesture>::StaticMethod("onActionCancel", &JSGesture::JsHandlerOnActionCancel);
703     JSClass<JSPanGesture>::Bind(globalObj);
704 
705     JSClass<JSSwipeGesture>::Declare("SwipeGesture");
706     JSClass<JSSwipeGesture>::StaticMethod("create", &JSSwipeGesture::Create, opt);
707     JSClass<JSSwipeGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
708     JSClass<JSSwipeGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
709     JSClass<JSSwipeGesture>::StaticMethod("pop", &JSGesture::Pop);
710     JSClass<JSSwipeGesture>::StaticMethod("onAction", &JSGesture::JsHandlerOnAction);
711     JSClass<JSSwipeGesture>::Bind(globalObj);
712 
713     JSClass<JSPinchGesture>::Declare("PinchGesture");
714     JSClass<JSPinchGesture>::StaticMethod("create", &JSPinchGesture::Create, opt);
715     JSClass<JSPinchGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
716     JSClass<JSPinchGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
717     JSClass<JSPinchGesture>::StaticMethod("pop", &JSGesture::Pop);
718     JSClass<JSPinchGesture>::StaticMethod("onActionStart", &JSGesture::JsHandlerOnActionStart);
719     JSClass<JSPinchGesture>::StaticMethod("onActionUpdate", &JSGesture::JsHandlerOnActionUpdate);
720     JSClass<JSPinchGesture>::StaticMethod("onActionEnd", &JSGesture::JsHandlerOnActionEnd);
721     JSClass<JSPinchGesture>::StaticMethod("onActionCancel", &JSGesture::JsHandlerOnActionCancel);
722     JSClass<JSPinchGesture>::Bind(globalObj);
723 
724     JSClass<JSRotationGesture>::Declare("RotationGesture");
725     JSClass<JSRotationGesture>::StaticMethod("create", &JSRotationGesture::Create, opt);
726     JSClass<JSRotationGesture>::StaticMethod("tag", &JSGesture::SetTag, opt);
727     JSClass<JSRotationGesture>::StaticMethod("allowedTypes", &JSGesture::SetAllowedTypes);
728     JSClass<JSRotationGesture>::StaticMethod("pop", &JSGesture::Pop);
729     JSClass<JSRotationGesture>::StaticMethod("onActionStart", &JSGesture::JsHandlerOnActionStart);
730     JSClass<JSRotationGesture>::StaticMethod("onActionUpdate", &JSGesture::JsHandlerOnActionUpdate);
731     JSClass<JSRotationGesture>::StaticMethod("onActionEnd", &JSGesture::JsHandlerOnActionEnd);
732     JSClass<JSRotationGesture>::StaticMethod("onActionCancel", &JSGesture::JsHandlerOnActionCancel);
733     JSClass<JSRotationGesture>::Bind(globalObj);
734 
735     JSClass<JSGestureGroup>::Declare("GestureGroup");
736     JSClass<JSGestureGroup>::StaticMethod("create", &JSGestureGroup::Create, opt);
737     JSClass<JSGestureGroup>::StaticMethod("pop", &JSGesture::Pop);
738     JSClass<JSGestureGroup>::StaticMethod("onCancel", &JSGesture::JsHandlerOnActionCancel);
739     JSClass<JSGestureGroup>::Bind<>(globalObj);
740 
741     JSClass<JSTimeoutGesture>::Declare("TimeoutGesture");
742     JSClass<JSTimeoutGesture>::StaticMethod("create", &JSTimeoutGesture::Create, opt);
743     JSClass<JSTimeoutGesture>::StaticMethod("pop", &JSGesture::Pop);
744 
745     JSClass<JSTimeoutGesture>::Bind<>(globalObj);
746 }
747 
Create(const JSCallbackInfo & args)748 void JSTimeoutGesture::Create(const JSCallbackInfo& args)
749 {
750     auto jsGesture = args[0];
751     if (!jsGesture->IsNumber()) {
752         return;
753     }
754 
755     RefPtr<GestureProcessor> gestureProcessor;
756     gestureProcessor = TimeoutGestureModel::GetInstance()->GetGestureProcessor();
757     auto gesture = AceType::MakeRefPtr<TimeoutGesture>(std::chrono::duration<float>(jsGesture->ToNumber<float>()));
758     gestureProcessor->PushGesture(gesture);
759 }
760 
JSBind(BindingTarget globalObj)761 void JSTimeoutGesture::JSBind(BindingTarget globalObj)
762 {
763     JSClass<JSTimeoutGesture>::Declare("TimeoutGesture");
764     MethodOptions opt = MethodOptions::NONE;
765     JSClass<JSTimeoutGesture>::StaticMethod("create", &JSTimeoutGesture::Create, opt);
766     JSClass<JSTimeoutGesture>::StaticMethod("pop", &JSGesture::Pop);
767 
768     JSClass<JSTimeoutGesture>::Bind<>(globalObj);
769 }
770 }; // namespace OHOS::Ace::Framework
771