1 /*
2  * Copyright (c) 2024 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 <cstdint>
17 
18 #include "native_gesture.h"
19 #include "native_node.h"
20 #include "native_type.h"
21 #include "node_model.h"
22 #include "gesture_impl.h"
23 
24 #include "base/utils/utils.h"
25 #include "core/gestures/gesture_event.h"
26 #include "frameworks/core/interfaces/arkoala/arkoala_api.h"
27 #include "interfaces/native/event/ui_input_event_impl.h"
28 
29 #ifdef __cplusplus
30 extern "C" {
31 #endif
32 
33 struct ArkUI_GestureRecognizer {
34     int32_t type = -1;
35     ArkUIGesture* gesture = nullptr;
36     void* extraData = nullptr;
37     void* attachNode = nullptr;
38     bool capi = true;
39     void* recognizer = nullptr;
40     ArkUIGestureEventTargetInfo targetInfo = {};
41 };
42 
43 struct ArkUI_GestureEventTargetInfo {
44     void* uiNode = nullptr;
45 };
46 
47 #ifdef __cplusplus
48 };
49 
50 // the ArkUI_GestureEvent struct actually same as ArkUIAPIEventGestureAsyncEvent;
51 struct ArkUI_GestureEvent {
52     ArkUIAPIEventGestureAsyncEvent eventData;
53     void* attachNode;
54 };
55 
56 struct ArkUI_GestureInterruptInfo {
57     ArkUIGestureInterruptInfo interruptData;
58 };
59 
60 struct ArkUI_ParallelInnerGestureEvent {
61     ArkUIGestureRecognizer* current = nullptr;
62     ArkUIGestureRecognizer** responseLinkRecognizer = nullptr;
63     void* userData = nullptr;
64     int32_t count;
65 };
66 
67 #endif
68 
69 
OH_ArkUI_GestureEvent_GetActionType(const ArkUI_GestureEvent * event)70 ArkUI_GestureEventActionType OH_ArkUI_GestureEvent_GetActionType(const ArkUI_GestureEvent* event)
71 {
72     ArkUI_GestureEventActionType ret;
73     switch (event->eventData.subKind) {
74         case ON_ACTION:
75         case ON_ACTION_START:
76             ret = GESTURE_EVENT_ACTION_ACCEPT;
77             break;
78         case ON_ACTION_UPDATE:
79             ret = GESTURE_EVENT_ACTION_UPDATE;
80             break;
81         case ON_ACTION_END:
82             ret = GESTURE_EVENT_ACTION_END;
83             break;
84         case ON_ACTION_CANCEL:
85             ret = GESTURE_EVENT_ACTION_CANCEL;
86             break;
87         default:
88             ret = GESTURE_EVENT_ACTION_ACCEPT;
89             break;
90     }
91     return ret;
92 }
93 
OH_ArkUI_GestureEvent_GetRawInputEvent(const ArkUI_GestureEvent * event)94 const ArkUI_UIInputEvent* OH_ArkUI_GestureEvent_GetRawInputEvent(const ArkUI_GestureEvent* event)
95 {
96     if (!event) {
97         return nullptr;
98     }
99     return reinterpret_cast<ArkUI_UIInputEvent*>(event->eventData.rawPointerEvent);
100 }
101 
OH_ArkUI_LongPress_GetRepeatCount(const ArkUI_GestureEvent * event)102 int32_t OH_ArkUI_LongPress_GetRepeatCount(const ArkUI_GestureEvent* event)
103 {
104     return event->eventData.repeat;
105 }
106 
OH_ArkUI_PanGesture_GetVelocity(const ArkUI_GestureEvent * event)107 float OH_ArkUI_PanGesture_GetVelocity(const ArkUI_GestureEvent* event)
108 {
109     return event->eventData.velocity;
110 }
111 
OH_ArkUI_PanGesture_GetVelocityX(const ArkUI_GestureEvent * event)112 float OH_ArkUI_PanGesture_GetVelocityX(const ArkUI_GestureEvent* event)
113 {
114     return event->eventData.velocityX;
115 }
116 
OH_ArkUI_PanGesture_GetVelocityY(const ArkUI_GestureEvent * event)117 float OH_ArkUI_PanGesture_GetVelocityY(const ArkUI_GestureEvent* event)
118 {
119     return event->eventData.velocityY;
120 }
121 
OH_ArkUI_PanGesture_GetOffsetX(const ArkUI_GestureEvent * event)122 float OH_ArkUI_PanGesture_GetOffsetX(const ArkUI_GestureEvent* event)
123 {
124     return event->eventData.x;
125 }
126 
OH_ArkUI_PanGesture_GetOffsetY(const ArkUI_GestureEvent * event)127 float OH_ArkUI_PanGesture_GetOffsetY(const ArkUI_GestureEvent* event)
128 {
129     return event->eventData.y;
130 }
131 
OH_ArkUI_SwipeGesture_GetAngle(const ArkUI_GestureEvent * event)132 float OH_ArkUI_SwipeGesture_GetAngle(const ArkUI_GestureEvent* event)
133 {
134     return event->eventData.angle;
135 }
136 
OH_ArkUI_SwipeGesture_GetVelocity(const ArkUI_GestureEvent * event)137 float OH_ArkUI_SwipeGesture_GetVelocity(const ArkUI_GestureEvent* event)
138 {
139     return event->eventData.speed;
140 }
141 
OH_ArkUI_RotationGesture_GetAngle(const ArkUI_GestureEvent * event)142 float OH_ArkUI_RotationGesture_GetAngle(const ArkUI_GestureEvent* event)
143 {
144     return event->eventData.angle;
145 }
146 
OH_ArkUI_PinchGesture_GetScale(const ArkUI_GestureEvent * event)147 float OH_ArkUI_PinchGesture_GetScale(const ArkUI_GestureEvent* event)
148 {
149     return event->eventData.scale;
150 }
151 
OH_ArkUI_PinchGesture_GetCenterX(const ArkUI_GestureEvent * event)152 float OH_ArkUI_PinchGesture_GetCenterX(const ArkUI_GestureEvent* event)
153 {
154     return event->eventData.pinchCenterX;
155 }
156 
OH_ArkUI_PinchGesture_GetCenterY(const ArkUI_GestureEvent * event)157 float OH_ArkUI_PinchGesture_GetCenterY(const ArkUI_GestureEvent* event)
158 {
159     return event->eventData.pinchCenterY;
160 }
161 
OH_ArkUI_GestureEvent_GetNode(const ArkUI_GestureEvent * event)162 ArkUI_NodeHandle OH_ArkUI_GestureEvent_GetNode(const ArkUI_GestureEvent* event)
163 {
164     if (!event) {
165         return nullptr;
166     }
167     return reinterpret_cast<ArkUI_NodeHandle>(event->attachNode);
168 }
169 
OH_ArkUI_GestureInterruptInfo_GetSystemFlag(const ArkUI_GestureInterruptInfo * event)170 bool OH_ArkUI_GestureInterruptInfo_GetSystemFlag(const ArkUI_GestureInterruptInfo* event)
171 {
172     return event->interruptData.isSystemGesture;
173 }
174 
OH_ArkUI_GestureInterruptInfo_GetRecognizer(const ArkUI_GestureInterruptInfo * event)175 ArkUI_GestureRecognizer* OH_ArkUI_GestureInterruptInfo_GetRecognizer(const ArkUI_GestureInterruptInfo* event)
176 {
177     return reinterpret_cast<ArkUI_GestureRecognizer *>(event->interruptData.userData);
178 }
179 
OH_ArkUI_GestureInterruptInfo_GetGestureEvent(const ArkUI_GestureInterruptInfo * event)180 ArkUI_GestureEvent* OH_ArkUI_GestureInterruptInfo_GetGestureEvent(const ArkUI_GestureInterruptInfo* event)
181 {
182     CHECK_NULL_RETURN(event, nullptr);
183     ArkUI_GestureEvent* gestureEvent = reinterpret_cast<ArkUI_GestureEvent*>(event->interruptData.gestureEvent);
184     CHECK_NULL_RETURN(gestureEvent, nullptr);
185 
186     ArkUI_UIInputEvent* uiEvent = reinterpret_cast<ArkUI_UIInputEvent*>(event->interruptData.inputEvent);
187     gestureEvent->eventData.rawPointerEvent = uiEvent;
188 
189     auto* gestureRecognizer = reinterpret_cast<ArkUI_GestureRecognizer*>(event->interruptData.userData);
190     CHECK_NULL_RETURN(gestureRecognizer, nullptr);
191     gestureEvent->attachNode = gestureRecognizer->attachNode;
192     return gestureEvent;
193 }
194 
OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType(const ArkUI_GestureInterruptInfo * event)195 int32_t OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType(const ArkUI_GestureInterruptInfo* event)
196 {
197     if (event->interruptData.isSystemGesture) {
198         return event->interruptData.systemRecognizerType;
199     }
200     return -1;
201 }
202 
OH_ArkUI_GetResponseRecognizersFromInterruptInfo(const ArkUI_GestureInterruptInfo * event,ArkUI_GestureRecognizerHandleArray * responseChain,int32_t * count)203 int32_t OH_ArkUI_GetResponseRecognizersFromInterruptInfo(
204     const ArkUI_GestureInterruptInfo* event, ArkUI_GestureRecognizerHandleArray* responseChain, int32_t* count)
205 {
206     CHECK_NULL_RETURN(responseChain, ARKUI_ERROR_CODE_PARAM_INVALID);
207     CHECK_NULL_RETURN(count, ARKUI_ERROR_CODE_PARAM_INVALID);
208     *responseChain = reinterpret_cast<ArkUI_GestureRecognizer**>(event->interruptData.responseLinkRecognizer);
209     *count = event->interruptData.count;
210     return 0;
211 }
212 
OH_ArkUI_SetGestureRecognizerEnabled(ArkUI_GestureRecognizer * recognizer,bool enabled)213 int32_t OH_ArkUI_SetGestureRecognizerEnabled(ArkUI_GestureRecognizer* recognizer, bool enabled)
214 {
215     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
216     if (!gestureRecognizer) {
217         return ARKUI_ERROR_CODE_PARAM_INVALID;
218     }
219     return OHOS::Ace::NodeModel::GetFullImpl()
220         ->getNodeModifiers()
221         ->getGestureModifier()
222         ->setGestureRecognizerEnabled(gestureRecognizer, enabled);
223 }
224 
OH_ArkUI_GetGestureRecognizerEnabled(ArkUI_GestureRecognizer * recognizer)225 bool OH_ArkUI_GetGestureRecognizerEnabled(ArkUI_GestureRecognizer* recognizer)
226 {
227     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
228     if (!gestureRecognizer) {
229         return false;
230     }
231     return OHOS::Ace::NodeModel::GetFullImpl()
232         ->getNodeModifiers()
233         ->getGestureModifier()
234         ->getGestureRecognizerEnabled(gestureRecognizer);
235 }
236 
OH_ArkUI_GetGestureRecognizerState(ArkUI_GestureRecognizer * recognizer,ArkUI_GestureRecognizerState * state)237 int32_t OH_ArkUI_GetGestureRecognizerState(ArkUI_GestureRecognizer* recognizer, ArkUI_GestureRecognizerState* state)
238 {
239     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
240     if (!gestureRecognizer) {
241         return ARKUI_ERROR_CODE_PARAM_INVALID;
242     }
243     ArkUIGestureRecognizerState recognizerState;
244     auto result =
245         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->getGestureRecognizerState(
246             gestureRecognizer, &recognizerState);
247     *state = static_cast<ArkUI_GestureRecognizerState>(recognizerState);
248     return result;
249 }
250 
OH_ArkUI_GetGestureEventTargetInfo(ArkUI_GestureRecognizer * recognizer,ArkUI_GestureEventTargetInfo ** info)251 int32_t OH_ArkUI_GetGestureEventTargetInfo(ArkUI_GestureRecognizer* recognizer, ArkUI_GestureEventTargetInfo** info)
252 {
253     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
254     if (!gestureRecognizer) {
255         return ARKUI_ERROR_CODE_PARAM_INVALID;
256     }
257     *info = reinterpret_cast<ArkUI_GestureEventTargetInfo*>(&gestureRecognizer->targetInfo);
258     return 0;
259 }
260 
OH_ArkUI_GestureEventTargetInfo_IsScrollBegin(ArkUI_GestureEventTargetInfo * info,bool * ret)261 int32_t OH_ArkUI_GestureEventTargetInfo_IsScrollBegin(ArkUI_GestureEventTargetInfo* info, bool* ret)
262 {
263     auto* targetInfo = reinterpret_cast<ArkUIGestureEventTargetInfo*>(info);
264     if (!targetInfo) {
265         return ARKUI_ERROR_CODE_PARAM_INVALID;
266     }
267     return OHOS::Ace::NodeModel::GetFullImpl()
268         ->getNodeModifiers()
269         ->getGestureModifier()
270         ->gestureEventTargetInfoIsScrollBegin(targetInfo, ret);
271 }
272 
OH_ArkUI_GestureEventTargetInfo_IsScrollEnd(ArkUI_GestureEventTargetInfo * info,bool * ret)273 int32_t OH_ArkUI_GestureEventTargetInfo_IsScrollEnd(ArkUI_GestureEventTargetInfo* info, bool* ret)
274 {
275     auto* targetInfo = reinterpret_cast<ArkUIGestureEventTargetInfo*>(info);
276     if (!targetInfo) {
277         return ARKUI_ERROR_CODE_PARAM_INVALID;
278     }
279     return OHOS::Ace::NodeModel::GetFullImpl()
280         ->getNodeModifiers()
281         ->getGestureModifier()
282         ->gestureEventTargetInfoIsScrollEnd(targetInfo, ret);
283 }
284 
OH_ArkUI_GetPanGestureDirectionMask(ArkUI_GestureRecognizer * recognizer,ArkUI_GestureDirectionMask * directionMask)285 int32_t OH_ArkUI_GetPanGestureDirectionMask(
286     ArkUI_GestureRecognizer* recognizer, ArkUI_GestureDirectionMask* directionMask)
287 {
288     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
289     if (!gestureRecognizer) {
290         return ARKUI_ERROR_CODE_PARAM_INVALID;
291     }
292     ArkUIGestureDirection direction = ArkUIGestureDirection::ArkUI_GESTURE_DIRECTION_ALL;
293     auto result =
294         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->getPanGestureDirectionMask(
295             gestureRecognizer, &direction);
296     *directionMask = static_cast<ArkUI_GestureDirectionMask>(direction);
297     return result;
298 }
299 
OH_ArkUI_IsBuiltInGesture(ArkUI_GestureRecognizer * recognizer)300 bool OH_ArkUI_IsBuiltInGesture(ArkUI_GestureRecognizer* recognizer)
301 {
302     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
303     if (!gestureRecognizer) {
304         return false;
305     }
306     return OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->isBuiltInGesture(
307         gestureRecognizer);
308 }
309 
OH_ArkUI_GetGestureTag(ArkUI_GestureRecognizer * recognizer,char * buffer,int32_t bufferSize,int32_t * result)310 int32_t OH_ArkUI_GetGestureTag(ArkUI_GestureRecognizer* recognizer, char* buffer, int32_t bufferSize, int32_t* result)
311 {
312     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
313     if (!gestureRecognizer) {
314         return ARKUI_ERROR_CODE_PARAM_INVALID;
315     }
316     return OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->getGestureTag(
317         gestureRecognizer, buffer, bufferSize, result);
318 }
319 
OH_ArkUI_GetGestureBindNodeId(ArkUI_GestureRecognizer * recognizer,char * nodeId,int32_t size,int32_t * result)320 int32_t OH_ArkUI_GetGestureBindNodeId(ArkUI_GestureRecognizer* recognizer, char* nodeId, int32_t size, int32_t* result)
321 {
322     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
323     if (!gestureRecognizer) {
324         return ARKUI_ERROR_CODE_PARAM_INVALID;
325     }
326     return OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->getGestureBindNodeId(
327         gestureRecognizer, nodeId, size, result);
328 }
329 
OH_ArkUI_IsGestureRecognizerValid(ArkUI_GestureRecognizer * recognizer)330 bool OH_ArkUI_IsGestureRecognizerValid(ArkUI_GestureRecognizer* recognizer)
331 {
332     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
333     if (!gestureRecognizer) {
334         return false;
335     }
336     return OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->isGestureRecognizerValid(
337         gestureRecognizer);
338 }
339 
OH_ArkUI_ParallelInnerGestureEvent_GetUserData(ArkUI_ParallelInnerGestureEvent * event)340 void* OH_ArkUI_ParallelInnerGestureEvent_GetUserData(ArkUI_ParallelInnerGestureEvent* event)
341 {
342     return event->userData;
343 }
344 
OH_ArkUI_ParallelInnerGestureEvent_GetCurrentRecognizer(ArkUI_ParallelInnerGestureEvent * event)345 ArkUI_GestureRecognizer* OH_ArkUI_ParallelInnerGestureEvent_GetCurrentRecognizer(ArkUI_ParallelInnerGestureEvent* event)
346 {
347     return reinterpret_cast<ArkUI_GestureRecognizer*>(event->current);
348 }
349 
OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(ArkUI_ParallelInnerGestureEvent * event,ArkUI_GestureRecognizerHandleArray * array,int32_t * size)350 int32_t OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(
351     ArkUI_ParallelInnerGestureEvent* event, ArkUI_GestureRecognizerHandleArray* array, int32_t* size)
352 {
353     CHECK_NULL_RETURN(array, ARKUI_ERROR_CODE_PARAM_INVALID);
354     CHECK_NULL_RETURN(size, ARKUI_ERROR_CODE_PARAM_INVALID);
355     *array = reinterpret_cast<ArkUI_GestureRecognizer**>(event->responseLinkRecognizer);
356     *size = event->count;
357     return 0;
358 }
359 
OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify(ArkUI_GestureRecognizer * recognizer,ArkUI_GestureRecognizerDisposeNotifyCallback callback,void * userData)360 int32_t OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify(
361     ArkUI_GestureRecognizer* recognizer, ArkUI_GestureRecognizerDisposeNotifyCallback callback, void* userData)
362 {
363     auto* gestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
364     if (!gestureRecognizer || gestureRecognizer->capi) {
365         return ARKUI_ERROR_CODE_PARAM_INVALID;
366     }
367     auto disposeCallback = reinterpret_cast<void (*)(ArkUIGestureRecognizer * recognizer, void* userData)>(callback);
368     OHOS::Ace::NodeModel::GetFullImpl()
369         ->getNodeModifiers()
370         ->getGestureModifier()
371         ->setArkUIGestureRecognizerDisposeNotify(gestureRecognizer, userData, disposeCallback);
372     return 0;
373 }
374 
375 namespace OHOS::Ace::GestureModel {
376 
377 constexpr int32_t DEFAULT_PAN_FINGERS = 1;
378 constexpr int32_t MAX_PAN_FINGERS = 10;
379 constexpr double DEFAULT_PINCH_DISTANCE = 5.0f;
380 constexpr double DEFAULT_SWIPE_SPEED = 100.0f;
381 constexpr int32_t DEFAULT_TAP_COUNT = 1;
382 constexpr int32_t DEFAULT_TAP_FINGERS = 1;
383 constexpr int32_t MAX_TAP_FINGERS = 10;
384 
385 struct GestureInnerData {
386     void (*targetReceiver)(ArkUI_GestureEvent* event, void* extraParam);
387     void* extraParam;
388     void* gesture;
389 };
390 
CreatePanGesture(int32_t fingersNum,ArkUI_GestureDirectionMask mask,double distanceNum)391 ArkUI_GestureRecognizer* CreatePanGesture(int32_t fingersNum, ArkUI_GestureDirectionMask mask, double distanceNum)
392 {
393     int32_t fingers = DEFAULT_PAN_FINGERS;
394     if (fingersNum < DEFAULT_PAN_FINGERS || fingersNum > MAX_PAN_FINGERS) {
395         fingers = DEFAULT_PAN_FINGERS;
396     } else {
397         fingers = fingersNum;
398     }
399     auto* ndkGesture = new ArkUI_GestureRecognizer{ PAN_GESTURE, nullptr, nullptr };
400     auto* gesture = OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createPanGesture(
401         fingers, mask, distanceNum, ndkGesture);
402     ndkGesture->gesture = gesture;
403     return ndkGesture;
404 }
405 
CreateTapGesture(int32_t count,int32_t fingers)406 ArkUI_GestureRecognizer* CreateTapGesture(int32_t count, int32_t fingers)
407 {
408     count = std::max(count, DEFAULT_TAP_COUNT);
409     fingers = std::clamp(fingers, DEFAULT_TAP_FINGERS, MAX_TAP_FINGERS);
410     auto* ndkGesture = new ArkUI_GestureRecognizer{ TAP_GESTURE, nullptr, nullptr, nullptr };
411     auto* gesture = OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createTapGesture(
412         count, fingers, ndkGesture);
413     ndkGesture->gesture = gesture;
414     return ndkGesture;
415 }
416 
CreateTapGestureWithDistanceThreshold(int32_t count,int32_t fingers,double distanceThreshold)417 ArkUI_GestureRecognizer* CreateTapGestureWithDistanceThreshold(int32_t count, int32_t fingers, double distanceThreshold)
418 {
419     count = std::max(count, DEFAULT_TAP_COUNT);
420     fingers = std::clamp(fingers, DEFAULT_TAP_FINGERS, MAX_TAP_FINGERS);
421     auto* ndkGesture = new ArkUI_GestureRecognizer{ TAP_GESTURE, nullptr, nullptr, nullptr };
422     auto* gesture = OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->
423         createTapGestureWithDistanceThreshold(count, fingers, distanceThreshold, ndkGesture);
424     ndkGesture->gesture = gesture;
425     return ndkGesture;
426 }
427 
CreateLongPressGesture(int32_t fingers,bool repeatResult,int32_t duration)428 ArkUI_GestureRecognizer* CreateLongPressGesture(int32_t fingers, bool repeatResult, int32_t duration)
429 {
430     auto* ndkGesture = new ArkUI_GestureRecognizer{ LONG_PRESS_GESTURE, nullptr, nullptr, nullptr };
431     auto* gesture =
432         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createLongPressGesture(fingers,
433         repeatResult, duration, ndkGesture);
434     ndkGesture->gesture = gesture;
435     return ndkGesture;
436 }
437 
CreatePinchGesture(int32_t fingers,double distance)438 ArkUI_GestureRecognizer* CreatePinchGesture(int32_t fingers, double distance)
439 {
440     if (LessOrEqual(distance, 0.0f)) {
441         distance = DEFAULT_PINCH_DISTANCE;
442     }
443     double distanceNum = OHOS::Ace::NodeModel::GetFullImpl()->getBasicAPI()->convertLengthMetricsUnit(
444         distance, static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_PX), static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_VP));
445     auto* ndkGesture = new ArkUI_GestureRecognizer{ PINCH_GESTURE, nullptr, nullptr, nullptr };
446     auto* gesture =
447         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createPinchGesture(fingers,
448         distanceNum, ndkGesture);
449     ndkGesture->gesture = gesture;
450     return ndkGesture;
451 }
452 
CreateRotationGesture(int32_t fingers,double angle)453 ArkUI_GestureRecognizer* CreateRotationGesture(int32_t fingers, double angle)
454 {
455     auto* ndkGesture = new ArkUI_GestureRecognizer{ ROTATION_GESTURE, nullptr, nullptr, nullptr };
456     auto* gesture =
457         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createRotationGesture(fingers,
458         angle, ndkGesture);
459     ndkGesture->gesture = gesture;
460     return ndkGesture;
461 }
462 
CreateSwipeGesture(int32_t fingers,ArkUI_GestureDirectionMask directions,double speed)463 ArkUI_GestureRecognizer* CreateSwipeGesture(int32_t fingers, ArkUI_GestureDirectionMask directions, double speed)
464 {
465     if (LessOrEqual(speed, 0.0f)) {
466         speed = DEFAULT_SWIPE_SPEED;
467     }
468     double speedNum = OHOS::Ace::NodeModel::GetFullImpl()->getBasicAPI()->convertLengthMetricsUnit(
469         speed, static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_PX), static_cast<int32_t>(ARKUI_LENGTH_METRIC_UNIT_VP));
470     auto* ndkGesture = new ArkUI_GestureRecognizer{ SWIPE_GESTURE, nullptr, nullptr, nullptr };
471     auto* gesture =
472         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createSwipeGesture(fingers,
473         directions, speedNum, ndkGesture);
474     ndkGesture->gesture = gesture;
475     return ndkGesture;
476 }
477 
DisposeGesture(ArkUI_GestureRecognizer * recognizer)478 void DisposeGesture(ArkUI_GestureRecognizer* recognizer)
479 {
480     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->dispose(recognizer->gesture);
481     delete reinterpret_cast<GestureInnerData*>(recognizer->extraData);
482     recognizer->extraData = nullptr;
483     delete recognizer;
484     recognizer = nullptr;
485 }
486 
SetGestureEventTarget(ArkUI_GestureRecognizer * recognizer,ArkUI_GestureEventActionTypeMask mask,void * extraParam,void (* targetReceiver)(ArkUI_GestureEvent * event,void * extraParam))487 int32_t SetGestureEventTarget(ArkUI_GestureRecognizer* recognizer, ArkUI_GestureEventActionTypeMask mask,
488     void* extraParam, void (*targetReceiver)(ArkUI_GestureEvent* event, void* extraParam))
489 {
490     // 手势事件通过通用的异步事件接口进行处理。(HandleGestureEvent)
491     // 把回调函数和上下文都封装到内部结构体中。
492     if (recognizer->extraData) {
493         delete reinterpret_cast<GestureInnerData*>(recognizer->extraData);
494         recognizer->extraData = nullptr;
495     }
496     recognizer->extraData = new GestureInnerData { targetReceiver, extraParam, recognizer };
497     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->registerGestureEvent(
498         recognizer->gesture, mask, recognizer->extraData);
499     return 0;
500 }
501 
AddGestureToNode(ArkUI_NodeHandle node,ArkUI_GestureRecognizer * recognizer,ArkUI_GesturePriority priorityNum,ArkUI_GestureMask mask)502 int32_t AddGestureToNode(ArkUI_NodeHandle node, ArkUI_GestureRecognizer* recognizer, ArkUI_GesturePriority priorityNum,
503     ArkUI_GestureMask mask)
504 {
505     recognizer->attachNode = node;
506     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->addGestureToNode(
507         node->uiNodeHandle, recognizer->gesture, priorityNum, mask);
508     recognizer->targetInfo.uiNode = reinterpret_cast<void*>(node->uiNodeHandle);
509     return 0;
510 }
511 
RemoveGestureFromNode(ArkUI_NodeHandle node,ArkUI_GestureRecognizer * recognizer)512 int32_t RemoveGestureFromNode(ArkUI_NodeHandle node, ArkUI_GestureRecognizer* recognizer)
513 {
514     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->removeGestureFromNode(
515         node->uiNodeHandle, recognizer->gesture);
516     recognizer->targetInfo.uiNode = nullptr;
517     return 0;
518 }
519 
GetGestureType(ArkUI_GestureRecognizer * recognizer)520 ArkUI_GestureRecognizerType GetGestureType(ArkUI_GestureRecognizer* recognizer)
521 {
522     return static_cast<ArkUI_GestureRecognizerType>(recognizer->type);
523 }
524 
CreateGroupGesture(ArkUI_GroupGestureMode gestureMode)525 ArkUI_GestureRecognizer* CreateGroupGesture(ArkUI_GroupGestureMode gestureMode)
526 {
527     auto* gesture =
528         OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->createGestureGroup(gestureMode);
529     return new ArkUI_GestureRecognizer { GROUP_GESTURE, gesture, nullptr };
530 }
531 
AddChildGesture(ArkUI_GestureRecognizer * group,ArkUI_GestureRecognizer * child)532 int32_t AddChildGesture(ArkUI_GestureRecognizer* group, ArkUI_GestureRecognizer* child)
533 {
534     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->addGestureToGestureGroup(
535         group->gesture, child->gesture);
536     return 0;
537 }
538 
RemoveChildGesture(ArkUI_GestureRecognizer * group,ArkUI_GestureRecognizer * child)539 int32_t RemoveChildGesture(ArkUI_GestureRecognizer* group, ArkUI_GestureRecognizer* child)
540 {
541     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->removeGestureFromGestureGroup(
542         group->gesture, child->gesture);
543     return 0;
544 }
545 
HandleGestureEvent(ArkUINodeEvent * event)546 void HandleGestureEvent(ArkUINodeEvent* event)
547 {
548     if (event == nullptr) {
549         return;
550     }
551     auto* extraData = reinterpret_cast<GestureInnerData*>(event->extraParam);
552     if (extraData == nullptr) {
553         return;
554     }
555     ArkUI_GestureEvent* gestureEvent = reinterpret_cast<ArkUI_GestureEvent *>(&event->gestureAsyncEvent);
556     if (gestureEvent == nullptr || extraData->targetReceiver == nullptr) {
557         return;
558     }
559     ArkUI_UIInputEvent uiEvent;
560     if (gestureEvent->eventData.inputEventType == static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_MOUSE)) {
561         uiEvent.eventTypeId = C_MOUSE_EVENT_ID;
562         uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_MOUSE;
563     } else if (gestureEvent->eventData.inputEventType == static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_AXIS)) {
564         uiEvent.eventTypeId = C_AXIS_EVENT_ID;
565         uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_AXIS;
566     } else {
567         uiEvent.eventTypeId = C_TOUCH_EVENT_ID;
568         uiEvent.inputType = ARKUI_UIINPUTEVENT_TYPE_TOUCH;
569     }
570     uiEvent.inputEvent = gestureEvent->eventData.rawPointerEvent;
571     gestureEvent->eventData.rawPointerEvent = &uiEvent;
572     if (extraData->gesture) {
573         ArkUI_GestureRecognizer* recognizer = reinterpret_cast<ArkUI_GestureRecognizer*>(extraData->gesture);
574         gestureEvent->attachNode = recognizer->attachNode;
575     }
576     extraData->targetReceiver(gestureEvent, extraData->extraParam);
577 }
578 
SetGestureInterrupterToNode(ArkUI_NodeHandle node,ArkUI_GestureInterruptResult (* interrupter)(ArkUI_GestureInterruptInfo * info))579 int32_t SetGestureInterrupterToNode(
580     ArkUI_NodeHandle node,  ArkUI_GestureInterruptResult (*interrupter)(ArkUI_GestureInterruptInfo* info))
581 {
582     auto callback = reinterpret_cast<int32_t (*)(ArkUIGestureInterruptInfo*)>(interrupter);
583     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->setGestureInterrupterToNode(
584         node->uiNodeHandle, callback);
585     return 0;
586 }
587 
SetInnerGestureParallelTo(ArkUI_NodeHandle node,void * userData,ArkUI_GestureRecognizer * (* parallelInnerGesture)(ArkUI_ParallelInnerGestureEvent * event))588 int32_t SetInnerGestureParallelTo(ArkUI_NodeHandle node, void* userData,
589     ArkUI_GestureRecognizer* (*parallelInnerGesture)(ArkUI_ParallelInnerGestureEvent* event))
590 {
591     auto callback =
592         reinterpret_cast<ArkUIGestureRecognizer* (*)(ArkUIParallelInnerGestureEvent * current)>(parallelInnerGesture);
593     OHOS::Ace::NodeModel::GetFullImpl()->getNodeModifiers()->getGestureModifier()->setInnerGestureParallelTo(
594         node->uiNodeHandle, userData, callback);
595     return 0;
596 }
597 
598 }; // namespace OHOS::Ace::GestureModel