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