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