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 "core/interfaces/native/node/node_gesture_modifier.h"
17 #include <securec.h>
18
19 #include "base/error/error_code.h"
20 #include "core/components_ng/base/ui_node.h"
21 #include "core/components_ng/gestures/long_press_gesture.h"
22 #include "core/components_ng/gestures/recognizers/gesture_recognizer.h"
23 #include "core/components_ng/gestures/recognizers/pan_recognizer.h"
24 #include "core/components_ng/pattern/gesture/gesture_model_ng.h"
25 #include "core/components_ng/gestures/pan_gesture.h"
26 #include "core/components_ng/gestures/pinch_gesture.h"
27 #include "core/components_ng/gestures/rotation_gesture.h"
28 #include "core/components_ng/gestures/swipe_gesture.h"
29 #include "core/components_ng/base/frame_node.h"
30 #include "core/components_ng/pattern/scrollable/scrollable_pattern.h"
31 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
32 #include "core/interfaces/native/node/touch_event_convertor.h"
33 #include "core/components_ng/base/view_abstract.h"
34 #include "core/components_ng/base/view_abstract_model_ng.h"
35 #include "core/interfaces/arkoala/arkoala_api.h"
36 #include "interfaces/native/event/ui_input_event_impl.h"
37 #include "interfaces/native/ui_input_event.h"
38
39 namespace OHOS::Ace::NG {
40 namespace {
41 constexpr int32_t MAX_POINTS = 10;
42 }
createPanGesture(ArkUI_Int32 fingers,ArkUI_Int32 direction,ArkUI_Float64 distance,void * userData)43 ArkUIGesture* createPanGesture(ArkUI_Int32 fingers, ArkUI_Int32 direction, ArkUI_Float64 distance, void* userData)
44 {
45 PanDirection panDirection;
46 switch (direction) {
47 case ArkUI_GESTURE_DIRECTION_ALL:
48 panDirection.type = panDirection.ALL;
49 break;
50 case ArkUI_GESTURE_DIRECTION_NONE:
51 panDirection.type = panDirection.NONE;
52 break;
53 case ArkUI_GESTURE_DIRECTION_LEFT:
54 panDirection.type = panDirection.LEFT;
55 break;
56 case ArkUI_GESTURE_DIRECTION_RIGHT:
57 panDirection.type = panDirection.RIGHT;
58 break;
59 case ArkUI_GESTURE_DIRECTION_HORIZONTAL:
60 panDirection.type = panDirection.HORIZONTAL;
61 break;
62 case ArkUI_GESTURE_DIRECTION_UP:
63 panDirection.type = panDirection.UP;
64 break;
65 case ArkUI_GESTURE_DIRECTION_DOWN:
66 panDirection.type = panDirection.DOWN;
67 break;
68 case ArkUI_GESTURE_DIRECTION_VERTICAL:
69 panDirection.type = panDirection.VERTICAL;
70 break;
71 default:
72 panDirection.type = panDirection.NONE;
73 break;
74 }
75 auto panGestureObject = AceType::MakeRefPtr<PanGesture>(fingers, panDirection, distance);
76 panGestureObject->SetUserData(userData);
77 panGestureObject->IncRefCount();
78 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(panGestureObject));
79 }
80
createTapGesture(ArkUI_Int32 count,ArkUI_Int32 fingers,void * userData)81 ArkUIGesture* createTapGesture(ArkUI_Int32 count, ArkUI_Int32 fingers, void* userData)
82 {
83 auto tapGestureObject = AceType::MakeRefPtr<TapGesture>(count, fingers, std::numeric_limits<double>::infinity());
84 tapGestureObject->SetUserData(userData);
85 tapGestureObject->IncRefCount();
86 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(tapGestureObject));
87 }
88
createTapGestureWithDistanceThreshold(ArkUI_Int32 count,ArkUI_Int32 fingers,double distanceThreshold,void * userData)89 ArkUIGesture* createTapGestureWithDistanceThreshold(
90 ArkUI_Int32 count, ArkUI_Int32 fingers, double distanceThreshold, void* userData)
91 {
92 distanceThreshold = Dimension(distanceThreshold, DimensionUnit::VP).ConvertToPx();
93 auto tapGestureObject = AceType::MakeRefPtr<TapGesture>(count, fingers, distanceThreshold);
94 tapGestureObject->SetUserData(userData);
95 tapGestureObject->IncRefCount();
96 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(tapGestureObject));
97 }
98
createLongPressGesture(ArkUI_Int32 fingers,bool repeat,ArkUI_Int32 duration,void * userData)99 ArkUIGesture* createLongPressGesture(ArkUI_Int32 fingers, bool repeat, ArkUI_Int32 duration, void* userData)
100 {
101 auto longPressGestureObject = AceType::MakeRefPtr<LongPressGesture>(fingers, repeat, duration);
102 longPressGestureObject->SetUserData(userData);
103 longPressGestureObject->IncRefCount();
104 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(longPressGestureObject));
105 }
106
createPinchGesture(ArkUI_Int32 fingers,ArkUI_Float64 distance,void * userData)107 ArkUIGesture* createPinchGesture(ArkUI_Int32 fingers, ArkUI_Float64 distance, void* userData)
108 {
109 auto pinchGestureObject = AceType::MakeRefPtr<PinchGesture>(fingers, distance);
110 pinchGestureObject->SetUserData(userData);
111 pinchGestureObject->IncRefCount();
112 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(pinchGestureObject));
113 }
114
createRotationGesture(ArkUI_Int32 fingers,ArkUI_Float64 angle,void * userData)115 ArkUIGesture* createRotationGesture(ArkUI_Int32 fingers, ArkUI_Float64 angle, void* userData)
116 {
117 auto rotationGestureObject = AceType::MakeRefPtr<RotationGesture>(fingers, angle);
118 rotationGestureObject->SetUserData(userData);
119 rotationGestureObject->IncRefCount();
120 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(rotationGestureObject));
121 }
122
createSwipeGesture(ArkUI_Int32 fingers,ArkUI_Int32 directions,ArkUI_Float64 speed,void * userData)123 ArkUIGesture* createSwipeGesture(ArkUI_Int32 fingers, ArkUI_Int32 directions, ArkUI_Float64 speed, void* userData)
124 {
125 SwipeDirection swipeDirection{SwipeDirection::NONE};
126 if (static_cast<uint32_t>(directions) & ArkUI_GESTURE_DIRECTION_HORIZONTAL) {
127 swipeDirection.type = SwipeDirection::HORIZONTAL;
128 }
129 if (static_cast<uint32_t>(directions) & ArkUI_GESTURE_DIRECTION_VERTICAL) {
130 swipeDirection.type += SwipeDirection::VERTICAL;
131 }
132 auto swipeGestureObject = AceType::MakeRefPtr<SwipeGesture>(fingers, swipeDirection, speed);
133 swipeGestureObject->SetUserData(userData);
134 swipeGestureObject->IncRefCount();
135 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(swipeGestureObject));
136 }
137
createSwipeGestureByModifier(ArkUI_Int32 fingers,ArkUI_Int32 direction,ArkUI_Float64 speed)138 ArkUIGesture* createSwipeGestureByModifier(ArkUI_Int32 fingers, ArkUI_Int32 direction, ArkUI_Float64 speed)
139 {
140 SwipeDirection swipeDirection{ SwipeDirection::NONE};
141 switch (direction) {
142 case ArkUI_SWIPE_GESTURE_DIRECTION_ALL:
143 swipeDirection.type = SwipeDirection::ALL;
144 break;
145 case ArkUI_SWIPE_GESTURE_DIRECTION_NONE:
146 swipeDirection.type = SwipeDirection::NONE;
147 break;
148 case ArkUI_SWIPE_GESTURE_DIRECTION_HORIZONTAL:
149 swipeDirection.type = SwipeDirection::HORIZONTAL;
150 break;
151 case ArkUI_SWIPE_GESTURE_DIRECTION_VERTICAL:
152 swipeDirection.type = SwipeDirection::VERTICAL;
153 break;
154 default:
155 swipeDirection.type = SwipeDirection::NONE;
156 break;
157 }
158 auto swipeGestureObject = AceType::MakeRefPtr<SwipeGesture>(fingers, swipeDirection, speed);
159 swipeGestureObject->IncRefCount();
160 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(swipeGestureObject));
161 }
162
createGestureGroup(ArkUI_Int32 mode)163 ArkUIGesture* createGestureGroup(ArkUI_Int32 mode)
164 {
165 auto gestureMode = static_cast<GestureMode>(mode);
166 auto gestureGroupObject = AceType::MakeRefPtr<GestureGroup>(gestureMode);
167 gestureGroupObject->IncRefCount();
168 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(gestureGroupObject));
169 }
170
addGestureToGestureGroup(ArkUIGesture * group,ArkUIGesture * child)171 void addGestureToGestureGroup(ArkUIGesture* group, ArkUIGesture* child)
172 {
173 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
174 auto* childGesture = reinterpret_cast<Gesture*>(child);
175 gestureGroup->AddGesture(AceType::Claim(childGesture));
176 }
177
addGestureToGestureGroupWithRefCountDecrease(ArkUIGesture * group,ArkUIGesture * child)178 void addGestureToGestureGroupWithRefCountDecrease(ArkUIGesture* group, ArkUIGesture* child)
179 {
180 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
181 auto* childGesture = reinterpret_cast<Gesture*>(child);
182 gestureGroup->AddGesture(AceType::Claim(childGesture));
183 // Gesture ptr ref count is not decrease, so need to decrease after attach to gestureEventHub.
184 childGesture->DecRefCount();
185 }
186
removeGestureFromGestureGroup(ArkUIGesture * group,ArkUIGesture * child)187 void removeGestureFromGestureGroup(ArkUIGesture* group, ArkUIGesture* child)
188 {
189 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
190 auto* childGesture = reinterpret_cast<Gesture*>(child);
191 gestureGroup->RemoveGesture(AceType::Claim(childGesture));
192 }
193
dispose(ArkUIGesture * recognizer)194 void dispose(ArkUIGesture* recognizer)
195 {
196 Gesture* gestureRef = reinterpret_cast<Gesture*>(recognizer);
197 gestureRef->SetDisposeTag(true);
198 gestureRef->DecRefCount();
199 }
200
ConvertTouchPointsToPoints(GestureEvent & info,std::vector<TouchPoint> & touchPointes,std::array<ArkUITouchPoint,MAX_POINTS> & points)201 void ConvertTouchPointsToPoints(GestureEvent& info, std::vector<TouchPoint>& touchPointes,
202 std::array<ArkUITouchPoint, MAX_POINTS>& points)
203 {
204 if (touchPointes.empty()) {
205 return;
206 }
207 size_t i = 0;
208 auto fingureIterator = std::begin(info.GetFingerList());
209 auto fingureEnd = std::end(info.GetFingerList());
210 for (auto& touchPoint : touchPointes) {
211 if (i >= MAX_POINTS) {
212 break;
213 }
214 points[i].id = touchPoint.id;
215 points[i].nodeX = fingureIterator == fingureEnd ? 0.0f : fingureIterator->localLocation_.GetX();
216 points[i].nodeY = fingureIterator == fingureEnd ? 0.0f : fingureIterator->localLocation_.GetY();
217 points[i].windowX = fingureIterator == fingureEnd ? 0.0f : fingureIterator->globalLocation_.GetX();
218 points[i].windowY = fingureIterator == fingureEnd ? 0.0f : fingureIterator->globalLocation_.GetY();
219 points[i].screenX = touchPoint.screenX;
220 points[i].screenY = touchPoint.screenY;
221 points[i].contactAreaWidth = touchPoint.size;
222 points[i].contactAreaHeight = touchPoint.size;
223 points[i].pressure = touchPoint.force;
224 points[i].tiltX = touchPoint.tiltX.value_or(0.0f);
225 points[i].tiltY = touchPoint.tiltY.value_or(0.0f);
226 points[i].pressedTime = touchPoint.downTime.time_since_epoch().count();
227 points[i].toolType = static_cast<int32_t>(touchPoint.sourceTool);
228 i++;
229 fingureIterator++;
230 }
231 }
232
ConvertIMMEventToTouchEvent(GestureEvent & info,ArkUITouchEvent & touchEvent,std::array<ArkUITouchPoint,MAX_POINTS> & points)233 void ConvertIMMEventToTouchEvent(GestureEvent& info, ArkUITouchEvent& touchEvent,
234 std::array<ArkUITouchPoint, MAX_POINTS>& points)
235 {
236 CHECK_NULL_VOID(info.GetPointerEvent());
237 auto tempTouchEvent = NG::ConvertToTouchEvent(info.GetPointerEvent());
238 touchEvent.action = static_cast<int32_t>(tempTouchEvent.type);
239 touchEvent.sourceType = static_cast<int32_t>(tempTouchEvent.sourceType);
240 touchEvent.timeStamp = tempTouchEvent.time.time_since_epoch().count();
241 touchEvent.actionTouchPoint.pressure = tempTouchEvent.force;
242 ConvertTouchPointsToPoints(info, tempTouchEvent.pointers, points);
243 if (tempTouchEvent.pointers.size() > 0) {
244 touchEvent.touchPointes = &(points[0]);
245 touchEvent.actionTouchPoint.nodeX = touchEvent.touchPointes[0].nodeX;
246 touchEvent.actionTouchPoint.nodeY = touchEvent.touchPointes[0].nodeY;
247 touchEvent.actionTouchPoint.windowX = touchEvent.touchPointes[0].windowX;
248 touchEvent.actionTouchPoint.windowY = touchEvent.touchPointes[0].windowY;
249 touchEvent.actionTouchPoint.screenX = touchEvent.touchPointes[0].screenX;
250 touchEvent.actionTouchPoint.screenY = touchEvent.touchPointes[0].screenY;
251 touchEvent.actionTouchPoint.toolType = touchEvent.touchPointes[0].toolType;
252 }
253 touchEvent.touchPointSize = tempTouchEvent.pointers.size() < MAX_POINTS ?
254 tempTouchEvent.pointers.size() : MAX_POINTS;
255 }
256
GetGestureEvent(ArkUIAPIEventGestureAsyncEvent & ret,GestureEvent & info)257 void GetGestureEvent(ArkUIAPIEventGestureAsyncEvent& ret, GestureEvent& info)
258 {
259 ret.repeat = info.GetRepeat();
260 ret.velocityX = info.GetVelocity().GetVelocityX();
261 ret.velocityY = info.GetVelocity().GetVelocityY();
262 ret.velocity = info.GetVelocity().GetVelocityValue();
263 ret.x = info.GetOffsetX();
264 ret.y = info.GetOffsetY();
265 ret.angle = info.GetAngle();
266 ret.scale = info.GetScale();
267 ret.pinchCenterX = info.GetPinchCenter().GetX();
268 ret.pinchCenterY = info.GetPinchCenter().GetY();
269 ret.speed = info.GetSpeed();
270 ret.source = static_cast<int32_t>(info.GetSourceDevice());
271 }
272
GetBaseGestureEvent(ArkUIAPIEventGestureAsyncEvent * ret,ArkUITouchEvent & rawInputEvent,const std::shared_ptr<BaseGestureEvent> & info)273 void GetBaseGestureEvent(ArkUIAPIEventGestureAsyncEvent* ret, ArkUITouchEvent& rawInputEvent,
274 const std::shared_ptr<BaseGestureEvent>& info)
275 {
276 rawInputEvent.sourceType = static_cast<ArkUI_Int32>(info->GetSourceDevice());
277 rawInputEvent.timeStamp = info->GetTimeStamp().time_since_epoch().count();
278 rawInputEvent.actionTouchPoint.tiltX = info->GetTiltX().value_or(0.0f);
279 rawInputEvent.actionTouchPoint.tiltY = info->GetTiltY().value_or(0.0f);
280 rawInputEvent.actionTouchPoint.toolType = static_cast<ArkUI_Int32>(info->GetSourceTool());
281 rawInputEvent.actionTouchPoint.pressure = info->GetForce();
282 std::array<ArkUITouchPoint, MAX_POINTS> points;
283 auto fingerList = info->GetFingerList();
284 auto fingureIterator = std::begin(fingerList);
285 for (size_t i = 0; i < fingerList.size(); i++) {
286 points[i].id = fingureIterator->fingerId_;
287 points[i].windowX = fingureIterator->globalLocation_.GetX();
288 points[i].windowY = fingureIterator->globalLocation_.GetY();
289 points[i].nodeX = fingureIterator->localLocation_.GetX();
290 points[i].nodeY = fingureIterator->localLocation_.GetY();
291 points[i].tiltX = rawInputEvent.actionTouchPoint.tiltX;
292 points[i].tiltY = rawInputEvent.actionTouchPoint.tiltY;
293 fingureIterator++;
294 }
295 rawInputEvent.touchPointes = &(points[0]);
296 rawInputEvent.touchPointSize = fingerList.size();
297 ret->rawPointerEvent = &rawInputEvent;
298 }
299
GetUniqueGestureEvent(ArkUIAPIEventGestureAsyncEvent * ret,GestureTypeName typeName,const std::shared_ptr<BaseGestureEvent> & info)300 void GetUniqueGestureEvent(ArkUIAPIEventGestureAsyncEvent* ret, GestureTypeName typeName,
301 const std::shared_ptr<BaseGestureEvent>& info)
302 {
303 switch (typeName) {
304 case OHOS::Ace::GestureTypeName::LONG_PRESS_GESTURE: {
305 auto longPressGestureEvent = TypeInfoHelper::DynamicCast<LongPressGestureEvent>(info.get());
306 if (longPressGestureEvent) {
307 ret->repeat = longPressGestureEvent->GetRepeat();
308 }
309 break;
310 }
311 case OHOS::Ace::GestureTypeName::PAN_GESTURE: {
312 auto panGestureEvent = TypeInfoHelper::DynamicCast<PanGestureEvent>(info.get());
313 if (panGestureEvent) {
314 ret->x = panGestureEvent->GetOffsetX();
315 ret->y = panGestureEvent->GetOffsetY();
316 ret->velocityX = panGestureEvent->GetVelocity().GetVelocityX();
317 ret->velocityY = panGestureEvent->GetVelocity().GetVelocityY();
318 ret->velocity = panGestureEvent->GetVelocity().GetVelocityValue();
319 }
320 break;
321 }
322 case OHOS::Ace::GestureTypeName::PINCH_GESTURE: {
323 auto pinchGestureEvent = TypeInfoHelper::DynamicCast<PinchGestureEvent>(info.get());
324 if (pinchGestureEvent) {
325 ret->scale = pinchGestureEvent->GetScale();
326 ret->pinchCenterX = pinchGestureEvent->GetPinchCenter().GetX();
327 ret->pinchCenterY = pinchGestureEvent->GetPinchCenter().GetY();
328 }
329 break;
330 }
331 case OHOS::Ace::GestureTypeName::ROTATION_GESTURE: {
332 auto rotationGestureEvent = TypeInfoHelper::DynamicCast<RotationGestureEvent>(info.get());
333 if (rotationGestureEvent) {
334 ret->angle = rotationGestureEvent->GetAngle();
335 }
336 break;
337 }
338 case OHOS::Ace::GestureTypeName::SWIPE_GESTURE: {
339 auto swipeGestureEvent = TypeInfoHelper::DynamicCast<SwipeGestureEvent>(info.get());
340 if (swipeGestureEvent) {
341 ret->angle = swipeGestureEvent->GetAngle();
342 ret->speed = swipeGestureEvent->GetSpeed();
343 }
344 break;
345 }
346 default:
347 break;
348 }
349 }
350
setCancelActionFunc(Gesture * gestureRef,void * extraParam)351 void setCancelActionFunc(Gesture* gestureRef, void* extraParam)
352 {
353 auto onActionCancel = [extraParam]() {
354 ArkUINodeEvent eventData;
355 eventData.kind = GESTURE_ASYNC_EVENT;
356 eventData.nodeId = 0;
357 eventData.extraParam = reinterpret_cast<ArkUI_Int64>(extraParam);
358 eventData.gestureAsyncEvent.subKind = ON_ACTION_CANCEL;
359 SendArkUIAsyncEvent(&eventData);
360 };
361 gestureRef->SetOnActionCancelId(onActionCancel);
362 }
363
ConvertIMMEventToMouseEvent(GestureEvent & info,ArkUIMouseEvent & mouseEvent)364 void ConvertIMMEventToMouseEvent(GestureEvent& info, ArkUIMouseEvent& mouseEvent)
365 {
366 CHECK_NULL_VOID(info.GetPointerEvent());
367 MouseEvent tempMouseEvent;
368 NG::ConvertToMouseEvent(tempMouseEvent, info.GetPointerEvent());
369 auto fingureBegin = std::begin(info.GetFingerList());
370 auto fingureEnd = std::end(info.GetFingerList());
371 mouseEvent.action = static_cast<int32_t>(tempMouseEvent.action);
372 mouseEvent.sourceType = static_cast<int32_t>(tempMouseEvent.sourceType);
373 mouseEvent.timeStamp = tempMouseEvent.time.time_since_epoch().count();
374 mouseEvent.actionTouchPoint.pressure = 0.0f;
375 mouseEvent.actionTouchPoint.nodeX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetX();
376 mouseEvent.actionTouchPoint.nodeY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetY();
377 mouseEvent.actionTouchPoint.windowX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetX();
378 mouseEvent.actionTouchPoint.windowY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetY();
379 mouseEvent.actionTouchPoint.screenX = tempMouseEvent.screenX;
380 mouseEvent.actionTouchPoint.screenY = tempMouseEvent.screenY;
381 mouseEvent.actionTouchPoint.toolType = static_cast<int32_t>(tempMouseEvent.sourceTool);
382 }
383
SendGestureEvent(GestureEvent & info,int32_t eventKind,void * extraParam)384 void SendGestureEvent(GestureEvent& info, int32_t eventKind, void* extraParam)
385 {
386 ArkUINodeEvent eventData;
387 eventData.kind = GESTURE_ASYNC_EVENT;
388 eventData.nodeId = 0;
389 eventData.extraParam = reinterpret_cast<ArkUI_Int64>(extraParam);
390 eventData.gestureAsyncEvent.subKind = eventKind;
391 GetGestureEvent(eventData.gestureAsyncEvent, info);
392 if (info.GetSourceDevice() == SourceType::MOUSE) {
393 ArkUIMouseEvent rawInputEvent;
394 ConvertIMMEventToMouseEvent(info, rawInputEvent);
395 eventData.gestureAsyncEvent.rawPointerEvent = &rawInputEvent;
396 SendArkUIAsyncEvent(&eventData);
397 return;
398 }
399 ArkUITouchEvent rawInputEvent;
400 std::array<ArkUITouchPoint, MAX_POINTS> points;
401 ConvertIMMEventToTouchEvent(info, rawInputEvent, points);
402 eventData.gestureAsyncEvent.rawPointerEvent = &rawInputEvent;
403 SendArkUIAsyncEvent(&eventData);
404 }
405
registerGestureEvent(ArkUIGesture * gesture,ArkUI_Uint32 actionTypeMask,void * extraParam)406 void registerGestureEvent(ArkUIGesture* gesture, ArkUI_Uint32 actionTypeMask, void* extraParam)
407 {
408 Gesture* gestureRef = reinterpret_cast<Gesture*>(gesture);
409 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_ACCEPT) {
410 auto onActionAccept = [extraParam](GestureEvent& info) {
411 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_START), extraParam);
412 };
413 gestureRef->SetOnActionId(onActionAccept);
414 gestureRef->SetOnActionStartId(onActionAccept);
415 }
416 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_UPDATE) {
417 auto onActionUpdate = [extraParam](GestureEvent& info) {
418 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_UPDATE), extraParam);
419 };
420 gestureRef->SetOnActionUpdateId(onActionUpdate);
421 }
422 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_END) {
423 auto onActionEnd = [extraParam](GestureEvent& info) {
424 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_END), extraParam);
425 };
426 gestureRef->SetOnActionEndId(onActionEnd);
427 }
428 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_CANCEL) {
429 setCancelActionFunc(gestureRef, extraParam);
430 }
431 }
432
addGestureToNode(ArkUINodeHandle node,ArkUIGesture * gesture,ArkUI_Int32 priorityNum,ArkUI_Int32 mask)433 void addGestureToNode(ArkUINodeHandle node, ArkUIGesture* gesture, ArkUI_Int32 priorityNum, ArkUI_Int32 mask)
434 {
435 auto* frameNode = reinterpret_cast<FrameNode*>(node);
436 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
437 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
438
439 GesturePriority priority = GesturePriority::Low;
440 if (priorityNum > static_cast<int32_t>(GesturePriority::Begin) &&
441 priorityNum < static_cast<int32_t>(GesturePriority::End)) {
442 priority = static_cast<GesturePriority>(priorityNum);
443 }
444 gesturePtr->SetPriority(priority);
445
446 GestureMask gestureMask = GestureMask::Normal;
447 if (mask > static_cast<int32_t>(GestureMask::Begin) &&
448 mask < static_cast<int32_t>(GestureMask::End)) {
449 gestureMask = static_cast<GestureMask>(mask);
450 }
451 gesturePtr->SetGestureMask(gestureMask);
452 gestureHub->AttachGesture(gesturePtr);
453 }
454
addGestureToNodeWithRefCountDecrease(ArkUINodeHandle node,ArkUIGesture * gesture,ArkUI_Int32 priorityNum,ArkUI_Int32 mask)455 void addGestureToNodeWithRefCountDecrease(
456 ArkUINodeHandle node, ArkUIGesture* gesture, ArkUI_Int32 priorityNum, ArkUI_Int32 mask)
457 {
458 auto* frameNode = reinterpret_cast<FrameNode*>(node);
459 CHECK_NULL_VOID(frameNode);
460 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
461 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
462
463 GesturePriority priority = GesturePriority::Low;
464 if (priorityNum > static_cast<int32_t>(GesturePriority::Begin) &&
465 priorityNum < static_cast<int32_t>(GesturePriority::End)) {
466 priority = static_cast<GesturePriority>(priorityNum);
467 }
468 gesturePtr->SetPriority(priority);
469
470 GestureMask gestureMask = GestureMask::Normal;
471 if (mask > static_cast<int32_t>(GestureMask::Begin) &&
472 mask < static_cast<int32_t>(GestureMask::End)) {
473 gestureMask = static_cast<GestureMask>(mask);
474 }
475 gesturePtr->SetGestureMask(gestureMask);
476 gestureHub->AttachGesture(gesturePtr);
477 // Gesture ptr ref count is not decrease, so need to decrease after attach to gestureEventHub.
478 gesturePtr->DecRefCount();
479 }
480
removeGestureFromNode(ArkUINodeHandle node,ArkUIGesture * gesture)481 void removeGestureFromNode(ArkUINodeHandle node, ArkUIGesture* gesture)
482 {
483 auto* frameNode = reinterpret_cast<FrameNode*>(node);
484 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
485 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
486 gestureHub->RemoveGesture(gesturePtr);
487 }
488
removeGestureFromNodeByTag(ArkUINodeHandle node,ArkUI_CharPtr gestureTag)489 void removeGestureFromNodeByTag(ArkUINodeHandle node, ArkUI_CharPtr gestureTag)
490 {
491 auto* frameNode = reinterpret_cast<FrameNode*>(node);
492 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
493 std::string tag(gestureTag);
494 gestureHub->RemoveGesturesByTag(tag);
495 }
496
clearGestures(ArkUINodeHandle node)497 void clearGestures(ArkUINodeHandle node)
498 {
499 auto* frameNode = reinterpret_cast<FrameNode*>(node);
500 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
501 gestureHub->ClearModifierGesture();
502 }
503
setGestureInterrupterToNode(ArkUINodeHandle node,ArkUI_Int32 (* interrupter)(ArkUIGestureInterruptInfo * interrupterInfo))504 void setGestureInterrupterToNode(
505 ArkUINodeHandle node, ArkUI_Int32 (*interrupter)(ArkUIGestureInterruptInfo* interrupterInfo))
506 {
507 auto* frameNode = reinterpret_cast<FrameNode*>(node);
508 auto onGestureRecognizerJudgeBegin = [frameNode, interrupter](const std::shared_ptr<BaseGestureEvent>& info,
509 const RefPtr<NG::NGGestureRecognizer>& current,
510 const std::list<RefPtr<NG::NGGestureRecognizer>>& others) -> GestureJudgeResult {
511 ArkUIAPIEventGestureAsyncEvent gestureEvent;
512 ArkUITouchEvent rawInputEvent;
513 GetBaseGestureEvent(&gestureEvent, rawInputEvent, info);
514 auto gestureInfo = current->GetGestureInfo();
515 CHECK_NULL_RETURN(gestureInfo, GestureJudgeResult::CONTINUE);
516 GetUniqueGestureEvent(&gestureEvent, gestureInfo->GetRecognizerType(), info);
517 ArkUIGestureInterruptInfo interruptInfo;
518 interruptInfo.isSystemGesture = gestureInfo->IsSystemGesture();
519 interruptInfo.systemRecognizerType = static_cast<ArkUI_Int32>(gestureInfo->GetType());
520 interruptInfo.event = &gestureEvent;
521 interruptInfo.userData = gestureInfo->GetUserData();
522 ArkUIGestureRecognizer* currentArkUIGestureRecognizer = NodeModifier::CreateGestureRecognizer(current);
523 interruptInfo.userData = reinterpret_cast<void*>(currentArkUIGestureRecognizer);
524 auto count = static_cast<int32_t>(others.size());
525 ArkUIGestureRecognizer** othersRecognizer = nullptr;
526 if (count > 0) {
527 othersRecognizer = new ArkUIGestureRecognizer* [count];
528 }
529 int32_t index = 0;
530 for (const auto& item : others) {
531 othersRecognizer[index] = NodeModifier::CreateGestureRecognizer(item);
532 index++;
533 }
534 interruptInfo.responseLinkRecognizer = othersRecognizer;
535 interruptInfo.count = count;
536 ArkUI_UIInputEvent inputEvent { ARKUI_UIINPUTEVENT_TYPE_TOUCH, C_TOUCH_EVENT_ID,
537 &rawInputEvent };
538 ArkUIGestureEvent arkUIGestureEvent { gestureEvent, nullptr };
539 interruptInfo.inputEvent = &inputEvent;
540 interruptInfo.gestureEvent = &arkUIGestureEvent;
541 auto result = interrupter(&interruptInfo);
542 delete[] othersRecognizer;
543 return static_cast<GestureJudgeResult>(result);
544 };
545 ViewAbstract::SetOnGestureRecognizerJudgeBegin(frameNode, std::move(onGestureRecognizerJudgeBegin));
546 }
547
setInnerGestureParallelTo(ArkUINodeHandle node,void * userData,ArkUIGestureRecognizer * (* parallelInnerGesture)(ArkUIParallelInnerGestureEvent * event))548 ArkUI_Int32 setInnerGestureParallelTo(ArkUINodeHandle node, void* userData,
549 ArkUIGestureRecognizer* (*parallelInnerGesture)(ArkUIParallelInnerGestureEvent* event))
550 {
551 auto* frameNode = reinterpret_cast<FrameNode*>(node);
552 auto parallelInnerGestureTo =
553 [userData, parallelInnerGesture](const RefPtr<NGGestureRecognizer>& current,
554 const std::vector<RefPtr<NGGestureRecognizer>>& others) -> RefPtr<NGGestureRecognizer> {
555 auto* currentArkUIGestureRecognizer = NodeModifier::CreateGestureRecognizer(current);
556 auto count = static_cast<int32_t>(others.size());
557 ArkUIGestureRecognizer** othersArkUIGestureRecognizer = nullptr;
558 if (count > 0) {
559 othersArkUIGestureRecognizer = new ArkUIGestureRecognizer* [count];
560 }
561 for (auto index = 0; index < count; index++) {
562 othersArkUIGestureRecognizer[index] = NodeModifier::CreateGestureRecognizer(others[index]);
563 }
564 ArkUIParallelInnerGestureEvent parallelInnerGestureEvent;
565 parallelInnerGestureEvent.current = currentArkUIGestureRecognizer;
566 parallelInnerGestureEvent.responseLinkRecognizer = othersArkUIGestureRecognizer;
567 parallelInnerGestureEvent.userData = userData;
568 parallelInnerGestureEvent.count = count;
569 auto* result = parallelInnerGesture(¶llelInnerGestureEvent);
570 if (!result || !result->recognizer) {
571 return nullptr;
572 }
573 delete[] othersArkUIGestureRecognizer;
574 return AceType::Claim(reinterpret_cast<NG::NGGestureRecognizer*>(result->recognizer));
575 };
576 ViewAbstract::SetShouldBuiltInRecognizerParallelWith(frameNode, std::move(parallelInnerGestureTo));
577 return ERROR_CODE_NO_ERROR;
578 }
579
setGestureRecognizerEnabled(ArkUIGestureRecognizer * recognizer,bool enabled)580 ArkUI_Int32 setGestureRecognizerEnabled(ArkUIGestureRecognizer* recognizer, bool enabled)
581 {
582 auto* gestureRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
583 CHECK_NULL_RETURN(gestureRecognizer, ERROR_CODE_PARAM_INVALID);
584 gestureRecognizer->SetEnabled(enabled);
585 return ERROR_CODE_NO_ERROR;
586 }
587
getGestureRecognizerEnabled(ArkUIGestureRecognizer * recognizer)588 ArkUI_Bool getGestureRecognizerEnabled(ArkUIGestureRecognizer* recognizer)
589 {
590 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
591 CHECK_NULL_RETURN(rawRecognizer, false);
592 auto gestureRecognizer = AceType::Claim(rawRecognizer);
593 return gestureRecognizer->IsEnabled();
594 }
595
getGestureRecognizerState(ArkUIGestureRecognizer * recognizer,ArkUIGestureRecognizerState * state)596 ArkUI_Int32 getGestureRecognizerState(ArkUIGestureRecognizer* recognizer, ArkUIGestureRecognizerState* state)
597 {
598 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
599 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
600 auto gestureRecognizer = AceType::Claim(rawRecognizer);
601 switch (gestureRecognizer->GetRefereeState()) {
602 case NG::RefereeState::READY:
603 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_READY;
604 return ERROR_CODE_NO_ERROR;
605 case NG::RefereeState::DETECTING:
606 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_DETECTING;
607 return ERROR_CODE_NO_ERROR;
608 case NG::RefereeState::PENDING:
609 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_PENDING;
610 return ERROR_CODE_NO_ERROR;
611 case NG::RefereeState::PENDING_BLOCKED:
612 case NG::RefereeState::SUCCEED_BLOCKED:
613 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_BLOCKED;
614 return ERROR_CODE_NO_ERROR;
615 case NG::RefereeState::SUCCEED:
616 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_SUCCESSFUL;
617 return ERROR_CODE_NO_ERROR;
618 case NG::RefereeState::FAIL:
619 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_FAILED;
620 return ERROR_CODE_NO_ERROR;
621 default:
622 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_READY;
623 return ERROR_CODE_PARAM_INVALID;
624 }
625 }
626
gestureEventTargetInfoIsScrollBegin(ArkUIGestureEventTargetInfo * info,bool * ret)627 ArkUI_Int32 gestureEventTargetInfoIsScrollBegin(ArkUIGestureEventTargetInfo* info, bool* ret)
628 {
629 auto frameNode = AceType::Claim(reinterpret_cast<NG::FrameNode*>(info->uiNode));
630 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
631 auto scrollablePattern = frameNode->GetPattern<NG::ScrollablePattern>();
632 if (scrollablePattern) {
633 *ret = scrollablePattern->IsAtTop();
634 return ERROR_CODE_NO_ERROR;
635 }
636 auto swiperPattern = frameNode->GetPattern<NG::SwiperPattern>();
637 if (swiperPattern) {
638 *ret = swiperPattern->IsAtStart();
639 return ERROR_CODE_NO_ERROR;
640 }
641 return ERROR_CODE_NON_SCROLLABLE_CONTAINER;
642 }
643
gestureEventTargetInfoIsScrollEnd(ArkUIGestureEventTargetInfo * info,bool * ret)644 ArkUI_Int32 gestureEventTargetInfoIsScrollEnd(ArkUIGestureEventTargetInfo* info, bool* ret)
645 {
646 auto frameNode = AceType::Claim(reinterpret_cast<NG::FrameNode*>(info->uiNode));
647 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
648 auto scrollablePattern = frameNode->GetPattern<NG::ScrollablePattern>();
649 if (scrollablePattern) {
650 *ret = scrollablePattern->IsAtBottom();
651 return ERROR_CODE_NO_ERROR;
652 }
653 auto swiperPattern = frameNode->GetPattern<NG::SwiperPattern>();
654 if (swiperPattern) {
655 *ret = swiperPattern->IsAtEnd();
656 return ERROR_CODE_NO_ERROR;
657 }
658 return ERROR_CODE_NON_SCROLLABLE_CONTAINER;
659 }
660
getPanGestureDirectionMask(ArkUIGestureRecognizer * recognizer,ArkUIGestureDirection * direction)661 ArkUI_Int32 getPanGestureDirectionMask(ArkUIGestureRecognizer* recognizer, ArkUIGestureDirection* direction)
662 {
663 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
664 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
665 auto gestureRecognizer = AceType::Claim(rawRecognizer);
666 auto panRecognizer = AceType::DynamicCast<PanRecognizer>(gestureRecognizer);
667 CHECK_NULL_RETURN(panRecognizer, ERROR_CODE_PARAM_INVALID);
668 *direction = static_cast<ArkUIGestureDirection>(panRecognizer->GetDirection().type);
669 return ERROR_CODE_NO_ERROR;
670 }
671
isBuiltInGesture(ArkUIGestureRecognizer * recognizer)672 ArkUI_Bool isBuiltInGesture(ArkUIGestureRecognizer* recognizer)
673 {
674 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
675 CHECK_NULL_RETURN(rawRecognizer, false);
676 auto gestureRecognizer = AceType::Claim(rawRecognizer);
677 return gestureRecognizer->IsSystemGesture();
678 }
679
getGestureTag(ArkUIGestureRecognizer * recognizer,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * result)680 ArkUI_Int32 getGestureTag(ArkUIGestureRecognizer* recognizer, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* result)
681 {
682 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
683 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
684 auto gestureRecognizer = AceType::Claim(rawRecognizer);
685 auto gestureInfo = gestureRecognizer->GetGestureInfo();
686 CHECK_NULL_RETURN(gestureInfo, ERROR_CODE_PARAM_INVALID);
687 auto gestureTag = gestureInfo->GetTag();
688 CHECK_NULL_RETURN(gestureTag.has_value(), ERROR_CODE_PARAM_INVALID);
689 auto actualSize = static_cast<int32_t>(gestureTag.value().size());
690 *result = actualSize;
691 if (actualSize > bufferSize - 1) {
692 return ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
693 }
694 auto count = snprintf_s(buffer, bufferSize, bufferSize - 1, "%s", gestureTag.value().c_str());
695 if (count < 0) {
696 return ERROR_CODE_PARAM_INVALID;
697 }
698 return ERROR_CODE_NO_ERROR;
699 }
700
getGestureBindNodeId(ArkUIGestureRecognizer * recognizer,char * nodeId,ArkUI_Int32 size,ArkUI_Int32 * result)701 ArkUI_Int32 getGestureBindNodeId(
702 ArkUIGestureRecognizer* recognizer, char* nodeId, ArkUI_Int32 size, ArkUI_Int32* result)
703 {
704 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
705 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
706 auto gestureRecognizer = AceType::Claim(rawRecognizer);
707 auto attachNode = gestureRecognizer->GetAttachedNode().Upgrade();
708 CHECK_NULL_RETURN(attachNode, ERROR_CODE_PARAM_INVALID);
709 auto inspectorId = attachNode->GetInspectorIdValue("");
710 auto actualSize = static_cast<int32_t>(inspectorId.size());
711 *result = actualSize;
712 if (actualSize > size - 1) {
713 return ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
714 }
715 auto count = snprintf_s(nodeId, size, size - 1, "%s", inspectorId.c_str());
716 if (count < 0) {
717 return ERROR_CODE_PARAM_INVALID;
718 }
719 return ERROR_CODE_NO_ERROR;
720 }
721
isGestureRecognizerValid(ArkUIGestureRecognizer * recognizer)722 ArkUI_Bool isGestureRecognizerValid(ArkUIGestureRecognizer* recognizer)
723 {
724 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
725 CHECK_NULL_RETURN(rawRecognizer, false);
726 auto gestureRecognizer = AceType::Claim(rawRecognizer);
727 return gestureRecognizer->IsInResponseLinkRecognizers();
728 }
729
setArkUIGestureRecognizerDisposeNotify(ArkUIGestureRecognizer * recognizer,void * userData,void (* callback)(ArkUIGestureRecognizer * recognizer,void * userData))730 ArkUI_Int32 setArkUIGestureRecognizerDisposeNotify(ArkUIGestureRecognizer* recognizer, void* userData,
731 void (*callback)(ArkUIGestureRecognizer* recognizer, void* userData))
732 {
733 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
734 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
735 auto gestureRecognizer = AceType::Claim(rawRecognizer);
736 auto disposeNotify = [userData, callback](void* recognizer) {
737 auto* arkuiGestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
738 callback(arkuiGestureRecognizer, userData);
739 };
740 gestureRecognizer->SetDisposeNotifyCallback(std::move(disposeNotify));
741 return ERROR_CODE_NO_ERROR;
742 }
743
744 namespace NodeModifier {
GetGestureModifier()745 const ArkUIGestureModifier* GetGestureModifier()
746 {
747 static const ArkUIGestureModifier modifier = {
748 createTapGesture,
749 createTapGestureWithDistanceThreshold,
750 createLongPressGesture,
751 createPanGesture,
752 createPinchGesture,
753 createRotationGesture,
754 createSwipeGesture,
755 createSwipeGestureByModifier,
756 createGestureGroup,
757 addGestureToGestureGroup,
758 removeGestureFromGestureGroup,
759 dispose,
760 registerGestureEvent,
761 addGestureToNode,
762 removeGestureFromNode,
763 removeGestureFromNodeByTag,
764 clearGestures,
765 setGestureInterrupterToNode,
766 setInnerGestureParallelTo,
767 setGestureRecognizerEnabled,
768 getGestureRecognizerEnabled,
769 getGestureRecognizerState,
770 gestureEventTargetInfoIsScrollBegin,
771 gestureEventTargetInfoIsScrollEnd,
772 getPanGestureDirectionMask,
773 isBuiltInGesture,
774 getGestureTag,
775 getGestureBindNodeId,
776 isGestureRecognizerValid,
777 setArkUIGestureRecognizerDisposeNotify,
778 addGestureToGestureGroupWithRefCountDecrease,
779 addGestureToNodeWithRefCountDecrease,
780 };
781 return &modifier;
782 }
783
GetCJUIGestureModifier()784 const CJUIGestureModifier* GetCJUIGestureModifier()
785 {
786 static const CJUIGestureModifier modifier = {
787 createTapGesture,
788 createLongPressGesture,
789 createPanGesture,
790 createPinchGesture,
791 createRotationGesture,
792 createSwipeGesture,
793 createSwipeGestureByModifier,
794 createGestureGroup,
795 addGestureToGestureGroup,
796 removeGestureFromGestureGroup,
797 dispose,
798 registerGestureEvent,
799 addGestureToNode,
800 removeGestureFromNode,
801 removeGestureFromNodeByTag,
802 clearGestures,
803 setGestureInterrupterToNode,
804 };
805 return &modifier;
806 }
807
CreateGestureRecognizer(const RefPtr<NG::NGGestureRecognizer> & recognizer)808 ArkUIGestureRecognizer* CreateGestureRecognizer(const RefPtr<NG::NGGestureRecognizer>& recognizer)
809 {
810 CHECK_NULL_RETURN(recognizer, nullptr);
811 ArkUIGestureRecognizer* arkUIGestureRecognizer;
812 auto gestureInfo = recognizer->GetGestureInfo();
813 CHECK_NULL_RETURN(gestureInfo, nullptr);
814 auto* userData = gestureInfo->GetUserData();
815 if (userData) {
816 arkUIGestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(userData);
817 } else {
818 arkUIGestureRecognizer = new ArkUIGestureRecognizer();
819 arkUIGestureRecognizer->capi = false;
820 gestureInfo->SetUserData(arkUIGestureRecognizer);
821 }
822 arkUIGestureRecognizer->type = static_cast<int32_t>(gestureInfo->GetRecognizerType());
823 arkUIGestureRecognizer->recognizer = reinterpret_cast<void*>(AceType::RawPtr(recognizer));
824 auto attachNode = recognizer->GetAttachedNode().Upgrade();
825 if (attachNode) {
826 arkUIGestureRecognizer->targetInfo.uiNode = reinterpret_cast<void*>(AceType::RawPtr(attachNode));
827 }
828 gestureInfo->SetIsCapi(arkUIGestureRecognizer->capi);
829 gestureInfo->SetDisposeJSRecognizerInfoFunc([arkUIGestureRecognizer]() {
830 delete arkUIGestureRecognizer;
831 });
832 return arkUIGestureRecognizer;
833 }
834 } // namespace NodeModifier
835 } // namespace OHOS::Ace::NG
836