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,bool limitFingerCount,void * userData=nullptr)43 ArkUIGesture* createPanGesture(
44 ArkUI_Int32 fingers, ArkUI_Int32 direction, ArkUI_Float64 distance, bool limitFingerCount, void* userData = nullptr)
45 {
46 PanDirection panDirection;
47 switch (direction) {
48 case ArkUI_GESTURE_DIRECTION_ALL:
49 panDirection.type = panDirection.ALL;
50 break;
51 case ArkUI_GESTURE_DIRECTION_NONE:
52 panDirection.type = panDirection.NONE;
53 break;
54 case ArkUI_GESTURE_DIRECTION_LEFT:
55 panDirection.type = panDirection.LEFT;
56 break;
57 case ArkUI_GESTURE_DIRECTION_RIGHT:
58 panDirection.type = panDirection.RIGHT;
59 break;
60 case ArkUI_GESTURE_DIRECTION_HORIZONTAL:
61 panDirection.type = panDirection.HORIZONTAL;
62 break;
63 case ArkUI_GESTURE_DIRECTION_UP:
64 panDirection.type = panDirection.UP;
65 break;
66 case ArkUI_GESTURE_DIRECTION_DOWN:
67 panDirection.type = panDirection.DOWN;
68 break;
69 case ArkUI_GESTURE_DIRECTION_VERTICAL:
70 panDirection.type = panDirection.VERTICAL;
71 break;
72 default:
73 panDirection.type = panDirection.NONE;
74 break;
75 }
76 auto panGestureObject = AceType::MakeRefPtr<PanGesture>(fingers, panDirection, distance, limitFingerCount);
77 panGestureObject->SetUserData(userData);
78 panGestureObject->IncRefCount();
79 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(panGestureObject));
80 }
81
createTapGesture(ArkUI_Int32 count,ArkUI_Int32 fingers,bool limitFingerCount=false,void * userData=nullptr)82 ArkUIGesture* createTapGesture(
83 ArkUI_Int32 count, ArkUI_Int32 fingers, bool limitFingerCount = false, void* userData = nullptr)
84 {
85 auto tapGestureObject = AceType::MakeRefPtr<TapGesture>(
86 count, fingers, std::numeric_limits<double>::infinity(), limitFingerCount);
87 tapGestureObject->SetUserData(userData);
88 tapGestureObject->IncRefCount();
89 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(tapGestureObject));
90 }
91
createTapGestureWithDistanceThreshold(ArkUI_Int32 count,ArkUI_Int32 fingers,double distanceThreshold,bool limitFingerCount=false,void * userData=nullptr)92 ArkUIGesture* createTapGestureWithDistanceThreshold(
93 ArkUI_Int32 count, ArkUI_Int32 fingers, double distanceThreshold, bool limitFingerCount = false,
94 void* userData = nullptr)
95 {
96 distanceThreshold = Dimension(distanceThreshold, DimensionUnit::VP).ConvertToPx();
97 auto tapGestureObject = AceType::MakeRefPtr<TapGesture>(count, fingers, distanceThreshold, limitFingerCount);
98 tapGestureObject->SetUserData(userData);
99 tapGestureObject->IncRefCount();
100 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(tapGestureObject));
101 }
102
createLongPressGesture(ArkUI_Int32 fingers,bool repeat,ArkUI_Int32 duration,bool limitFingerCount=false,void * userData=nullptr)103 ArkUIGesture* createLongPressGesture(
104 ArkUI_Int32 fingers, bool repeat, ArkUI_Int32 duration, bool limitFingerCount = false, void* userData = nullptr)
105 {
106 auto longPressGestureObject = AceType::MakeRefPtr<LongPressGesture>(
107 fingers, repeat, duration, false, false, limitFingerCount);
108 longPressGestureObject->SetUserData(userData);
109 longPressGestureObject->IncRefCount();
110 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(longPressGestureObject));
111 }
112
createPinchGesture(ArkUI_Int32 fingers,ArkUI_Float64 distance,bool limitFingerCount=false,void * userData=nullptr)113 ArkUIGesture* createPinchGesture(
114 ArkUI_Int32 fingers, ArkUI_Float64 distance, bool limitFingerCount = false, void* userData = nullptr)
115 {
116 auto pinchGestureObject = AceType::MakeRefPtr<PinchGesture>(fingers, distance, limitFingerCount);
117 pinchGestureObject->SetUserData(userData);
118 pinchGestureObject->IncRefCount();
119 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(pinchGestureObject));
120 }
121
createRotationGesture(ArkUI_Int32 fingers,ArkUI_Float64 angle,bool limitFingerCount=false,void * userData=nullptr)122 ArkUIGesture* createRotationGesture(
123 ArkUI_Int32 fingers, ArkUI_Float64 angle, bool limitFingerCount = false, void* userData = nullptr)
124 {
125 auto rotationGestureObject = AceType::MakeRefPtr<RotationGesture>(fingers, angle, limitFingerCount);
126 rotationGestureObject->SetUserData(userData);
127 rotationGestureObject->IncRefCount();
128 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(rotationGestureObject));
129 }
130
createSwipeGesture(ArkUI_Int32 fingers,ArkUI_Int32 directions,ArkUI_Float64 speed,bool limitFingerCount=false,void * userData=nullptr)131 ArkUIGesture* createSwipeGesture(
132 ArkUI_Int32 fingers, ArkUI_Int32 directions, ArkUI_Float64 speed, bool limitFingerCount = false,
133 void* userData = nullptr)
134 {
135 SwipeDirection swipeDirection{SwipeDirection::NONE};
136 if (static_cast<uint32_t>(directions) & ArkUI_GESTURE_DIRECTION_HORIZONTAL) {
137 swipeDirection.type = SwipeDirection::HORIZONTAL;
138 }
139 if (static_cast<uint32_t>(directions) & ArkUI_GESTURE_DIRECTION_VERTICAL) {
140 swipeDirection.type += SwipeDirection::VERTICAL;
141 }
142 auto swipeGestureObject = AceType::MakeRefPtr<SwipeGesture>(fingers, swipeDirection, speed, limitFingerCount);
143 swipeGestureObject->SetUserData(userData);
144 swipeGestureObject->IncRefCount();
145 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(swipeGestureObject));
146 }
147
createSwipeGestureByModifier(ArkUI_Int32 fingers,ArkUI_Int32 direction,ArkUI_Float64 speed,bool limitFingerCount=false)148 ArkUIGesture* createSwipeGestureByModifier(
149 ArkUI_Int32 fingers, ArkUI_Int32 direction, ArkUI_Float64 speed, bool limitFingerCount = false)
150 {
151 SwipeDirection swipeDirection{ SwipeDirection::NONE};
152 switch (direction) {
153 case ArkUI_SWIPE_GESTURE_DIRECTION_ALL:
154 swipeDirection.type = SwipeDirection::ALL;
155 break;
156 case ArkUI_SWIPE_GESTURE_DIRECTION_NONE:
157 swipeDirection.type = SwipeDirection::NONE;
158 break;
159 case ArkUI_SWIPE_GESTURE_DIRECTION_HORIZONTAL:
160 swipeDirection.type = SwipeDirection::HORIZONTAL;
161 break;
162 case ArkUI_SWIPE_GESTURE_DIRECTION_VERTICAL:
163 swipeDirection.type = SwipeDirection::VERTICAL;
164 break;
165 default:
166 swipeDirection.type = SwipeDirection::NONE;
167 break;
168 }
169 auto swipeGestureObject = AceType::MakeRefPtr<SwipeGesture>(fingers, swipeDirection, speed, limitFingerCount);
170 swipeGestureObject->IncRefCount();
171 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(swipeGestureObject));
172 }
173
createGestureGroup(ArkUI_Int32 mode)174 ArkUIGesture* createGestureGroup(ArkUI_Int32 mode)
175 {
176 auto gestureMode = static_cast<GestureMode>(mode);
177 auto gestureGroupObject = AceType::MakeRefPtr<GestureGroup>(gestureMode);
178 gestureGroupObject->IncRefCount();
179 return reinterpret_cast<ArkUIGesture*>(AceType::RawPtr(gestureGroupObject));
180 }
181
addGestureToGestureGroup(ArkUIGesture * group,ArkUIGesture * child)182 void addGestureToGestureGroup(ArkUIGesture* group, ArkUIGesture* child)
183 {
184 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
185 auto* childGesture = reinterpret_cast<Gesture*>(child);
186 gestureGroup->AddGesture(AceType::Claim(childGesture));
187 }
188
addGestureToGestureGroupWithRefCountDecrease(ArkUIGesture * group,ArkUIGesture * child)189 void addGestureToGestureGroupWithRefCountDecrease(ArkUIGesture* group, ArkUIGesture* child)
190 {
191 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
192 auto* childGesture = reinterpret_cast<Gesture*>(child);
193 gestureGroup->AddGesture(AceType::Claim(childGesture));
194 // Gesture ptr ref count is not decrease, so need to decrease after attach to gestureEventHub.
195 childGesture->DecRefCount();
196 }
197
removeGestureFromGestureGroup(ArkUIGesture * group,ArkUIGesture * child)198 void removeGestureFromGestureGroup(ArkUIGesture* group, ArkUIGesture* child)
199 {
200 auto* gestureGroup = reinterpret_cast<GestureGroup*>(group);
201 auto* childGesture = reinterpret_cast<Gesture*>(child);
202 gestureGroup->RemoveGesture(AceType::Claim(childGesture));
203 }
204
dispose(ArkUIGesture * recognizer)205 void dispose(ArkUIGesture* recognizer)
206 {
207 Gesture* gestureRef = reinterpret_cast<Gesture*>(recognizer);
208 gestureRef->SetDisposeTag(true);
209 gestureRef->DecRefCount();
210 }
211
ConvertTouchPointsToPoints(GestureEvent & info,std::vector<TouchPoint> & touchPointes,std::array<ArkUITouchPoint,MAX_POINTS> & points)212 void ConvertTouchPointsToPoints(GestureEvent& info, std::vector<TouchPoint>& touchPointes,
213 std::array<ArkUITouchPoint, MAX_POINTS>& points)
214 {
215 if (touchPointes.empty()) {
216 return;
217 }
218 size_t i = 0;
219 auto fingureIterator = std::begin(info.GetFingerList());
220 auto fingureEnd = std::end(info.GetFingerList());
221 for (auto& touchPoint : touchPointes) {
222 if (i >= MAX_POINTS) {
223 break;
224 }
225 points[i].id = touchPoint.id;
226 points[i].nodeX = fingureIterator == fingureEnd ? 0.0f : fingureIterator->localLocation_.GetX();
227 points[i].nodeY = fingureIterator == fingureEnd ? 0.0f : fingureIterator->localLocation_.GetY();
228 points[i].windowX = fingureIterator == fingureEnd ? 0.0f : fingureIterator->globalLocation_.GetX();
229 points[i].windowY = fingureIterator == fingureEnd ? 0.0f : fingureIterator->globalLocation_.GetY();
230 points[i].screenX = touchPoint.screenX;
231 points[i].screenY = touchPoint.screenY;
232 points[i].contactAreaWidth = touchPoint.size;
233 points[i].contactAreaHeight = touchPoint.size;
234 points[i].pressure = touchPoint.force;
235 points[i].tiltX = touchPoint.tiltX.value_or(0.0f);
236 points[i].tiltY = touchPoint.tiltY.value_or(0.0f);
237 points[i].pressedTime = touchPoint.downTime.time_since_epoch().count();
238 points[i].toolType = static_cast<int32_t>(touchPoint.sourceTool);
239 points[i].operatingHand = fingureIterator == fingureEnd ? 0 : fingureIterator->operatingHand_;
240 i++;
241 if (fingureIterator != fingureEnd) {
242 fingureIterator++;
243 }
244 }
245 }
246
ConvertIMMEventToTouchEvent(GestureEvent & info,ArkUITouchEvent & touchEvent,std::array<ArkUITouchPoint,MAX_POINTS> & points)247 void ConvertIMMEventToTouchEvent(GestureEvent& info, ArkUITouchEvent& touchEvent,
248 std::array<ArkUITouchPoint, MAX_POINTS>& points)
249 {
250 CHECK_NULL_VOID(info.GetPointerEvent());
251 auto tempTouchEvent = NG::ConvertToTouchEvent(info.GetPointerEvent());
252 touchEvent.action = static_cast<int32_t>(tempTouchEvent.type);
253 touchEvent.sourceType = static_cast<int32_t>(tempTouchEvent.sourceType);
254 touchEvent.timeStamp = tempTouchEvent.time.time_since_epoch().count();
255 touchEvent.actionTouchPoint.pressure = tempTouchEvent.force;
256 ConvertTouchPointsToPoints(info, tempTouchEvent.pointers, points);
257 if (tempTouchEvent.pointers.size() > 0) {
258 touchEvent.touchPointes = &(points[0]);
259 touchEvent.actionTouchPoint.nodeX = touchEvent.touchPointes[0].nodeX;
260 touchEvent.actionTouchPoint.nodeY = touchEvent.touchPointes[0].nodeY;
261 touchEvent.actionTouchPoint.windowX = touchEvent.touchPointes[0].windowX;
262 touchEvent.actionTouchPoint.windowY = touchEvent.touchPointes[0].windowY;
263 touchEvent.actionTouchPoint.screenX = touchEvent.touchPointes[0].screenX;
264 touchEvent.actionTouchPoint.screenY = touchEvent.touchPointes[0].screenY;
265 touchEvent.actionTouchPoint.toolType = touchEvent.touchPointes[0].toolType;
266 touchEvent.actionTouchPoint.operatingHand = touchEvent.touchPointes[0].operatingHand;
267 }
268 touchEvent.touchPointSize = tempTouchEvent.pointers.size() < MAX_POINTS ?
269 tempTouchEvent.pointers.size() : MAX_POINTS;
270 touchEvent.targetDisplayId = info.GetTargetDisplayId();
271 }
272
GetGestureEvent(ArkUIAPIEventGestureAsyncEvent & ret,GestureEvent & info)273 void GetGestureEvent(ArkUIAPIEventGestureAsyncEvent& ret, GestureEvent& info)
274 {
275 ret.repeat = info.GetRepeat();
276 ret.velocityX = info.GetVelocity().GetVelocityX();
277 ret.velocityY = info.GetVelocity().GetVelocityY();
278 ret.velocity = info.GetVelocity().GetVelocityValue();
279 ret.x = info.GetOffsetX();
280 ret.y = info.GetOffsetY();
281 ret.angle = info.GetAngle();
282 ret.scale = info.GetScale();
283 ret.pinchCenterX = info.GetPinchCenter().GetX();
284 ret.pinchCenterY = info.GetPinchCenter().GetY();
285 ret.speed = info.GetSpeed();
286 ret.source = static_cast<int32_t>(info.GetSourceDevice());
287 ret.targetDisplayId = info.GetTargetDisplayId();
288 switch (info.GetInputEventType()) {
289 case InputEventType::TOUCH_SCREEN :
290 ret.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_TOUCH);
291 break;
292 case InputEventType::MOUSE_BUTTON:
293 ret.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_MOUSE);
294 break;
295 case InputEventType::AXIS :
296 ret.inputEventType = static_cast<int32_t>(ARKUI_UIINPUTEVENT_TYPE_AXIS);
297 break;
298 default:
299 break;
300 }
301 }
302
GetBaseGestureEvent(ArkUIAPIEventGestureAsyncEvent * ret,ArkUITouchEvent & rawInputEvent,const std::shared_ptr<BaseGestureEvent> & info)303 void GetBaseGestureEvent(ArkUIAPIEventGestureAsyncEvent* ret, ArkUITouchEvent& rawInputEvent,
304 const std::shared_ptr<BaseGestureEvent>& info)
305 {
306 rawInputEvent.sourceType = static_cast<ArkUI_Int32>(info->GetSourceDevice());
307 rawInputEvent.timeStamp = info->GetTimeStamp().time_since_epoch().count();
308 rawInputEvent.actionTouchPoint.tiltX = info->GetTiltX().value_or(0.0f);
309 rawInputEvent.actionTouchPoint.tiltY = info->GetTiltY().value_or(0.0f);
310 rawInputEvent.actionTouchPoint.toolType = static_cast<ArkUI_Int32>(info->GetSourceTool());
311 rawInputEvent.actionTouchPoint.pressure = info->GetForce();
312 std::array<ArkUITouchPoint, MAX_POINTS> points;
313 auto fingerList = info->GetFingerList();
314 auto fingureIterator = std::begin(fingerList);
315 rawInputEvent.targetDisplayId = info->GetTargetDisplayId();
316
317 for (size_t i = 0; i < fingerList.size(); i++) {
318 points[i].id = fingureIterator->fingerId_;
319 points[i].windowX = fingureIterator->globalLocation_.GetX();
320 points[i].windowY = fingureIterator->globalLocation_.GetY();
321 points[i].nodeX = fingureIterator->localLocation_.GetX();
322 points[i].nodeY = fingureIterator->localLocation_.GetY();
323 points[i].tiltX = rawInputEvent.actionTouchPoint.tiltX;
324 points[i].tiltY = rawInputEvent.actionTouchPoint.tiltY;
325 fingureIterator++;
326 }
327 rawInputEvent.touchPointes = &(points[0]);
328 rawInputEvent.touchPointSize = fingerList.size();
329 ret->rawPointerEvent = &rawInputEvent;
330 }
331
GetUniqueGestureEvent(ArkUIAPIEventGestureAsyncEvent * ret,GestureTypeName typeName,const std::shared_ptr<BaseGestureEvent> & info)332 void GetUniqueGestureEvent(ArkUIAPIEventGestureAsyncEvent* ret, GestureTypeName typeName,
333 const std::shared_ptr<BaseGestureEvent>& info)
334 {
335 switch (typeName) {
336 case OHOS::Ace::GestureTypeName::LONG_PRESS_GESTURE: {
337 auto longPressGestureEvent = TypeInfoHelper::DynamicCast<LongPressGestureEvent>(info.get());
338 if (longPressGestureEvent) {
339 ret->repeat = longPressGestureEvent->GetRepeat();
340 }
341 break;
342 }
343 case OHOS::Ace::GestureTypeName::PAN_GESTURE: {
344 auto panGestureEvent = TypeInfoHelper::DynamicCast<PanGestureEvent>(info.get());
345 if (panGestureEvent) {
346 ret->x = panGestureEvent->GetOffsetX();
347 ret->y = panGestureEvent->GetOffsetY();
348 ret->velocityX = panGestureEvent->GetVelocity().GetVelocityX();
349 ret->velocityY = panGestureEvent->GetVelocity().GetVelocityY();
350 ret->velocity = panGestureEvent->GetVelocity().GetVelocityValue();
351 }
352 break;
353 }
354 case OHOS::Ace::GestureTypeName::PINCH_GESTURE: {
355 auto pinchGestureEvent = TypeInfoHelper::DynamicCast<PinchGestureEvent>(info.get());
356 if (pinchGestureEvent) {
357 ret->scale = pinchGestureEvent->GetScale();
358 ret->pinchCenterX = pinchGestureEvent->GetPinchCenter().GetX();
359 ret->pinchCenterY = pinchGestureEvent->GetPinchCenter().GetY();
360 }
361 break;
362 }
363 case OHOS::Ace::GestureTypeName::ROTATION_GESTURE: {
364 auto rotationGestureEvent = TypeInfoHelper::DynamicCast<RotationGestureEvent>(info.get());
365 if (rotationGestureEvent) {
366 ret->angle = rotationGestureEvent->GetAngle();
367 }
368 break;
369 }
370 case OHOS::Ace::GestureTypeName::SWIPE_GESTURE: {
371 auto swipeGestureEvent = TypeInfoHelper::DynamicCast<SwipeGestureEvent>(info.get());
372 if (swipeGestureEvent) {
373 ret->angle = swipeGestureEvent->GetAngle();
374 ret->speed = swipeGestureEvent->GetSpeed();
375 }
376 break;
377 }
378 default:
379 break;
380 }
381 }
382
setCancelActionFunc(Gesture * gestureRef,void * extraParam)383 void setCancelActionFunc(Gesture* gestureRef, void* extraParam)
384 {
385 auto onActionCancel = [extraParam]() {
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 = ON_ACTION_CANCEL;
391 SendArkUIAsyncEvent(&eventData);
392 };
393 gestureRef->SetOnActionCancelId(onActionCancel);
394 }
395
ConvertIMMEventToMouseEvent(GestureEvent & info,ArkUIMouseEvent & mouseEvent)396 void ConvertIMMEventToMouseEvent(GestureEvent& info, ArkUIMouseEvent& mouseEvent)
397 {
398 CHECK_NULL_VOID(info.GetPointerEvent());
399 MouseEvent tempMouseEvent;
400 NG::ConvertToMouseEvent(tempMouseEvent, info.GetPointerEvent());
401 auto fingureBegin = std::begin(info.GetFingerList());
402 auto fingureEnd = std::end(info.GetFingerList());
403 mouseEvent.action = static_cast<int32_t>(tempMouseEvent.action);
404 mouseEvent.sourceType = static_cast<int32_t>(tempMouseEvent.sourceType);
405 mouseEvent.timeStamp = tempMouseEvent.time.time_since_epoch().count();
406 mouseEvent.actionTouchPoint.pressure = 0.0f;
407 mouseEvent.actionTouchPoint.nodeX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetX();
408 mouseEvent.actionTouchPoint.nodeY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetY();
409 mouseEvent.actionTouchPoint.windowX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetX();
410 mouseEvent.actionTouchPoint.windowY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetY();
411 mouseEvent.actionTouchPoint.screenX = tempMouseEvent.screenX;
412 mouseEvent.actionTouchPoint.screenY = tempMouseEvent.screenY;
413 mouseEvent.actionTouchPoint.toolType = static_cast<int32_t>(tempMouseEvent.sourceTool);
414 mouseEvent.targetDisplayId = info.GetTargetDisplayId();
415 }
416
ConvertIMMEventToAxisEvent(GestureEvent & info,ArkUIAxisEvent & axisEvent)417 void ConvertIMMEventToAxisEvent(GestureEvent& info, ArkUIAxisEvent& axisEvent)
418 {
419 CHECK_NULL_VOID(info.GetPointerEvent());
420 AxisEvent tempAxisEvent;
421 NG::ConvertToAxisEvent(tempAxisEvent, info.GetPointerEvent());
422 auto fingureBegin = std::begin(info.GetFingerList());
423 auto fingureEnd = std::end(info.GetFingerList());
424 axisEvent.action = static_cast<int32_t>(tempAxisEvent.action);
425 axisEvent.sourceType = static_cast<int32_t>(tempAxisEvent.sourceType);
426 axisEvent.timeStamp = tempAxisEvent.time.time_since_epoch().count();
427 axisEvent.horizontalAxis = tempAxisEvent.horizontalAxis;
428 axisEvent.verticalAxis = tempAxisEvent.verticalAxis;
429 axisEvent.pinchAxisScale = tempAxisEvent.pinchAxisScale;
430 axisEvent.actionTouchPoint.nodeX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetX();
431 axisEvent.actionTouchPoint.nodeY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->localLocation_.GetY();
432 axisEvent.actionTouchPoint.windowX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetX();
433 axisEvent.actionTouchPoint.windowY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->globalLocation_.GetY();
434 axisEvent.actionTouchPoint.screenX = fingureBegin == fingureEnd ? 0.0f : fingureBegin->screenLocation_.GetX();
435 axisEvent.actionTouchPoint.screenY = fingureBegin == fingureEnd ? 0.0f : fingureBegin->screenLocation_.GetY();
436 axisEvent.actionTouchPoint.toolType = static_cast<int32_t>(tempAxisEvent.sourceTool);
437 axisEvent.targetDisplayId = info.GetTargetDisplayId();
438 }
439
SendGestureEvent(GestureEvent & info,int32_t eventKind,void * extraParam)440 void SendGestureEvent(GestureEvent& info, int32_t eventKind, void* extraParam)
441 {
442 ArkUINodeEvent eventData;
443 eventData.kind = GESTURE_ASYNC_EVENT;
444 eventData.nodeId = 0;
445 eventData.extraParam = reinterpret_cast<ArkUI_Int64>(extraParam);
446 eventData.gestureAsyncEvent.subKind = eventKind;
447 GetGestureEvent(eventData.gestureAsyncEvent, info);
448 if (info.GetInputEventType() == InputEventType::AXIS) {
449 ArkUIAxisEvent rawInputEvent;
450 ConvertIMMEventToAxisEvent(info, rawInputEvent);
451 eventData.gestureAsyncEvent.rawPointerEvent = &rawInputEvent;
452 SendArkUIAsyncEvent(&eventData);
453 return;
454 }
455 if (info.GetInputEventType() == InputEventType::MOUSE_BUTTON) {
456 ArkUIMouseEvent rawInputEvent;
457 ConvertIMMEventToMouseEvent(info, rawInputEvent);
458 eventData.gestureAsyncEvent.rawPointerEvent = &rawInputEvent;
459 SendArkUIAsyncEvent(&eventData);
460 return;
461 }
462 ArkUITouchEvent rawInputEvent;
463 std::array<ArkUITouchPoint, MAX_POINTS> points;
464 ConvertIMMEventToTouchEvent(info, rawInputEvent, points);
465 eventData.gestureAsyncEvent.rawPointerEvent = &rawInputEvent;
466 SendArkUIAsyncEvent(&eventData);
467 }
468
registerGestureEvent(ArkUIGesture * gesture,ArkUI_Uint32 actionTypeMask,void * extraParam)469 void registerGestureEvent(ArkUIGesture* gesture, ArkUI_Uint32 actionTypeMask, void* extraParam)
470 {
471 Gesture* gestureRef = reinterpret_cast<Gesture*>(gesture);
472 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_ACCEPT) {
473 auto onActionAccept = [extraParam](GestureEvent& info) {
474 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_START), extraParam);
475 };
476 gestureRef->SetOnActionId(onActionAccept);
477 gestureRef->SetOnActionStartId(onActionAccept);
478 }
479 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_UPDATE) {
480 auto onActionUpdate = [extraParam](GestureEvent& info) {
481 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_UPDATE), extraParam);
482 };
483 gestureRef->SetOnActionUpdateId(onActionUpdate);
484 }
485 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_END) {
486 auto onActionEnd = [extraParam](GestureEvent& info) {
487 SendGestureEvent(info, static_cast<int32_t>(ON_ACTION_END), extraParam);
488 };
489 gestureRef->SetOnActionEndId(onActionEnd);
490 }
491 if (actionTypeMask & ARKUI_GESTURE_EVENT_ACTION_CANCEL) {
492 setCancelActionFunc(gestureRef, extraParam);
493 }
494 }
495
addGestureToNode(ArkUINodeHandle node,ArkUIGesture * gesture,ArkUI_Int32 priorityNum,ArkUI_Int32 mask)496 void addGestureToNode(ArkUINodeHandle node, ArkUIGesture* gesture, ArkUI_Int32 priorityNum, ArkUI_Int32 mask)
497 {
498 auto* frameNode = reinterpret_cast<FrameNode*>(node);
499 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
500 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
501
502 GesturePriority priority = GesturePriority::Low;
503 if (priorityNum > static_cast<int32_t>(GesturePriority::Begin) &&
504 priorityNum < static_cast<int32_t>(GesturePriority::End)) {
505 priority = static_cast<GesturePriority>(priorityNum);
506 }
507 gesturePtr->SetPriority(priority);
508
509 GestureMask gestureMask = GestureMask::Normal;
510 if (mask > static_cast<int32_t>(GestureMask::Begin) &&
511 mask < static_cast<int32_t>(GestureMask::End)) {
512 gestureMask = static_cast<GestureMask>(mask);
513 }
514 gesturePtr->SetGestureMask(gestureMask);
515 gestureHub->AttachGesture(gesturePtr);
516 }
517
addGestureToNodeWithRefCountDecrease(ArkUINodeHandle node,ArkUIGesture * gesture,ArkUI_Int32 priorityNum,ArkUI_Int32 mask)518 void addGestureToNodeWithRefCountDecrease(
519 ArkUINodeHandle node, ArkUIGesture* gesture, ArkUI_Int32 priorityNum, ArkUI_Int32 mask)
520 {
521 auto* frameNode = reinterpret_cast<FrameNode*>(node);
522 CHECK_NULL_VOID(frameNode);
523 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
524 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
525
526 GesturePriority priority = GesturePriority::Low;
527 if (priorityNum > static_cast<int32_t>(GesturePriority::Begin) &&
528 priorityNum < static_cast<int32_t>(GesturePriority::End)) {
529 priority = static_cast<GesturePriority>(priorityNum);
530 }
531 gesturePtr->SetPriority(priority);
532
533 GestureMask gestureMask = GestureMask::Normal;
534 if (mask > static_cast<int32_t>(GestureMask::Begin) &&
535 mask < static_cast<int32_t>(GestureMask::End)) {
536 gestureMask = static_cast<GestureMask>(mask);
537 }
538 gesturePtr->SetGestureMask(gestureMask);
539 gestureHub->AttachGesture(gesturePtr);
540 // Gesture ptr ref count is not decrease, so need to decrease after attach to gestureEventHub.
541 gesturePtr->DecRefCount();
542 }
543
removeGestureFromNode(ArkUINodeHandle node,ArkUIGesture * gesture)544 void removeGestureFromNode(ArkUINodeHandle node, ArkUIGesture* gesture)
545 {
546 auto* frameNode = reinterpret_cast<FrameNode*>(node);
547 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
548 auto gesturePtr = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
549 gestureHub->RemoveGesture(gesturePtr);
550 }
551
removeGestureFromNodeByTag(ArkUINodeHandle node,ArkUI_CharPtr gestureTag)552 void removeGestureFromNodeByTag(ArkUINodeHandle node, ArkUI_CharPtr gestureTag)
553 {
554 auto* frameNode = reinterpret_cast<FrameNode*>(node);
555 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
556 std::string tag(gestureTag);
557 gestureHub->RemoveGesturesByTag(tag);
558 }
559
clearGestures(ArkUINodeHandle node)560 void clearGestures(ArkUINodeHandle node)
561 {
562 auto* frameNode = reinterpret_cast<FrameNode*>(node);
563 auto gestureHub = frameNode->GetOrCreateGestureEventHub();
564 gestureHub->ClearModifierGesture();
565 }
566
567 // <fingerid, iterator of touchTestResults in eventManager>
568 using TouchRecoginerTarget = std::vector<std::pair<int32_t, TouchTestResult::iterator>>;
569 using TouchRecognizerMap = std::map<TouchEventTarget*, TouchRecoginerTarget>;
570
IsFingerCollectedByTarget(TouchRecoginerTarget & target,int32_t fingerId)571 bool IsFingerCollectedByTarget(TouchRecoginerTarget& target, int32_t fingerId)
572 {
573 for (const auto& item : target) {
574 if (item.first == fingerId) {
575 return true;
576 }
577 }
578 return false;
579 }
580
CollectTouchEventTarget(TouchRecognizerMap & dict,std::list<RefPtr<TouchEventTarget>> & targets,FrameNode * borderNode,int32_t fingerId)581 void CollectTouchEventTarget(
582 TouchRecognizerMap& dict, std::list<RefPtr<TouchEventTarget>>& targets, FrameNode* borderNode, int32_t fingerId)
583 {
584 for (auto iter = targets.begin(); iter != targets.end(); ++iter) {
585 auto& target = *iter;
586 if (AceType::DynamicCast<NG::NGGestureRecognizer>(target)) {
587 continue;
588 }
589 auto targetPtr = AceType::RawPtr(target);
590 if (dict.find(targetPtr) != dict.end() && IsFingerCollectedByTarget(dict[AceType::RawPtr(target)], fingerId)) {
591 continue;
592 }
593 auto targetNode = target->GetAttachedNode().Upgrade();
594 if (targetNode && targetNode == borderNode) {
595 dict[targetPtr].emplace_back(fingerId, iter);
596 return;
597 }
598 while (targetNode) {
599 if (targetNode == borderNode) {
600 dict[targetPtr].emplace_back(fingerId, iter);
601 break;
602 }
603 targetNode = targetNode->GetParentFrameNode();
604 }
605 }
606 }
607
CreateTouchRecognizers(FrameNode * frameNode,const std::shared_ptr<BaseGestureEvent> & info,ArkUIGestureInterruptInfo & interruptInfo)608 TouchRecognizerMap* CreateTouchRecognizers(
609 FrameNode* frameNode, const std::shared_ptr<BaseGestureEvent>& info, ArkUIGestureInterruptInfo& interruptInfo)
610 {
611 auto pipeline = frameNode->GetContext();
612 CHECK_NULL_RETURN(pipeline, nullptr);
613 auto eventManager = pipeline->GetEventManager();
614 CHECK_NULL_RETURN(eventManager, nullptr);
615 auto& touchTestResult = eventManager->touchTestResults_;
616 auto pTouchRecognizerMap = new TouchRecognizerMap;
617 TouchRecognizerMap::value_type** touchRecoginers = nullptr;
618 auto& touchRecognizerMap = *pTouchRecognizerMap;
619 const auto& fingerList = info->GetFingerList();
620 for (const auto& finger : fingerList) {
621 auto& touchTargetList = touchTestResult[finger.fingerId_];
622 CollectTouchEventTarget(touchRecognizerMap, touchTargetList, frameNode, finger.fingerId_);
623 }
624 touchRecoginers = new TouchRecognizerMap::value_type*[touchRecognizerMap.size()];
625 int32_t i = 0;
626 for (auto& item : touchRecognizerMap) {
627 touchRecoginers[i++] = &item;
628 }
629 interruptInfo.touchRecognizers = reinterpret_cast<void**>(touchRecoginers);
630 interruptInfo.touchRecognizerCnt = i;
631 return pTouchRecognizerMap;
632 }
633
DestroyTouchRecognizers(TouchRecognizerMap * recognizers,ArkUIGestureInterruptInfo & interruptInfo)634 void DestroyTouchRecognizers(TouchRecognizerMap* recognizers, ArkUIGestureInterruptInfo& interruptInfo)
635 {
636 if (recognizers) {
637 delete recognizers;
638 }
639 if (interruptInfo.touchRecognizers) {
640 delete[] reinterpret_cast<TouchRecognizerMap::value_type**>(interruptInfo.touchRecognizers);
641 }
642 }
643
touchRecognizerGetNodeHandle(void * recognizer)644 ArkUINodeHandle touchRecognizerGetNodeHandle(void* recognizer)
645 {
646 auto iter = static_cast<TouchRecognizerMap::value_type*>(recognizer);
647 TouchEventTarget* touchEventTarget = iter->first;
648 auto frameNode = touchEventTarget->GetAttachedNode().Upgrade();
649 CHECK_NULL_RETURN(frameNode, nullptr);
650 return reinterpret_cast<ArkUINodeHandle>(frameNode.GetRawPtr());
651 }
652
touchRecognizerCancelTouch(void * recognizer)653 ArkUI_Bool touchRecognizerCancelTouch(void* recognizer)
654 {
655 auto iter = static_cast<TouchRecognizerMap::value_type*>(recognizer);
656 TouchEventTarget* touchEventTarget = iter->first;
657 TouchRecoginerTarget& touchRecognizerTarget = iter->second;
658 auto node = touchEventTarget->GetAttachedNode().Upgrade();
659 CHECK_NULL_RETURN(node, false);
660 auto pipeline = node->GetContext();
661 CHECK_NULL_RETURN(pipeline, false);
662 auto eventManager = pipeline->GetEventManager();
663 CHECK_NULL_RETURN(eventManager, false);
664 if (!touchRecognizerTarget.empty()) {
665 eventManager->DispatchTouchCancelToRecognizer(touchEventTarget, touchRecognizerTarget);
666 touchRecognizerTarget.clear();
667 return true;
668 }
669 return false;
670 }
671
setGestureInterrupterToNode(ArkUINodeHandle node,ArkUI_Int32 (* interrupter)(ArkUIGestureInterruptInfo * interrupterInfo))672 void setGestureInterrupterToNode(
673 ArkUINodeHandle node, ArkUI_Int32 (*interrupter)(ArkUIGestureInterruptInfo* interrupterInfo))
674 {
675 auto* frameNode = reinterpret_cast<FrameNode*>(node);
676 CHECK_NULL_VOID(frameNode);
677 auto onGestureRecognizerJudgeBegin =
678 [weak = AceType::WeakClaim(frameNode), interrupter](const std::shared_ptr<BaseGestureEvent>& info,
679 const RefPtr<NG::NGGestureRecognizer>& current,
680 const std::list<RefPtr<NG::NGGestureRecognizer>>& others) -> GestureJudgeResult {
681 auto node = weak.Upgrade();
682 CHECK_NULL_RETURN(node, GestureJudgeResult::CONTINUE);
683 ArkUIAPIEventGestureAsyncEvent gestureEvent;
684 ArkUITouchEvent rawInputEvent;
685 GetBaseGestureEvent(&gestureEvent, rawInputEvent, info);
686 auto gestureInfo = current->GetGestureInfo();
687 CHECK_NULL_RETURN(gestureInfo, GestureJudgeResult::CONTINUE);
688 GetUniqueGestureEvent(&gestureEvent, gestureInfo->GetRecognizerType(), info);
689 ArkUIGestureInterruptInfo interruptInfo;
690 interruptInfo.isSystemGesture = gestureInfo->IsSystemGesture();
691 interruptInfo.systemRecognizerType = static_cast<ArkUI_Int32>(gestureInfo->GetType());
692 interruptInfo.event = &gestureEvent;
693 interruptInfo.userData = gestureInfo->GetUserData();
694 ArkUIGestureRecognizer* currentArkUIGestureRecognizer = NodeModifier::CreateGestureRecognizer(current);
695 interruptInfo.userData = reinterpret_cast<void*>(currentArkUIGestureRecognizer);
696 auto count = static_cast<int32_t>(others.size());
697 ArkUIGestureRecognizer** othersRecognizer = nullptr;
698 if (count > 0) {
699 othersRecognizer = new ArkUIGestureRecognizer* [count];
700 }
701 int32_t index = 0;
702 for (const auto& item : others) {
703 othersRecognizer[index] = NodeModifier::CreateGestureRecognizer(item);
704 index++;
705 }
706 interruptInfo.responseLinkRecognizer = othersRecognizer;
707 interruptInfo.count = count;
708 ArkUI_UIInputEvent inputEvent { ARKUI_UIINPUTEVENT_TYPE_TOUCH, C_TOUCH_EVENT_ID,
709 &rawInputEvent };
710 ArkUIGestureEvent arkUIGestureEvent { gestureEvent, nullptr };
711 interruptInfo.inputEvent = &inputEvent;
712 interruptInfo.gestureEvent = &arkUIGestureEvent;
713
714 auto touchRecognizers = CreateTouchRecognizers(AceType::RawPtr(node), info, interruptInfo);
715 auto result = interrupter(&interruptInfo);
716 delete[] othersRecognizer;
717 DestroyTouchRecognizers(touchRecognizers, interruptInfo);
718 return static_cast<GestureJudgeResult>(result);
719 };
720 ViewAbstract::SetOnGestureRecognizerJudgeBegin(frameNode, std::move(onGestureRecognizerJudgeBegin));
721 }
722
setInnerGestureParallelTo(ArkUINodeHandle node,void * userData,ArkUIGestureRecognizer * (* parallelInnerGesture)(ArkUIParallelInnerGestureEvent * event))723 ArkUI_Int32 setInnerGestureParallelTo(ArkUINodeHandle node, void* userData,
724 ArkUIGestureRecognizer* (*parallelInnerGesture)(ArkUIParallelInnerGestureEvent* event))
725 {
726 auto* frameNode = reinterpret_cast<FrameNode*>(node);
727 auto parallelInnerGestureTo =
728 [userData, parallelInnerGesture](const RefPtr<NGGestureRecognizer>& current,
729 const std::vector<RefPtr<NGGestureRecognizer>>& others) -> RefPtr<NGGestureRecognizer> {
730 auto* currentArkUIGestureRecognizer = NodeModifier::CreateGestureRecognizer(current);
731 auto count = static_cast<int32_t>(others.size());
732 ArkUIGestureRecognizer** othersArkUIGestureRecognizer = nullptr;
733 if (count > 0) {
734 othersArkUIGestureRecognizer = new ArkUIGestureRecognizer* [count];
735 }
736 for (auto index = 0; index < count; index++) {
737 othersArkUIGestureRecognizer[index] = NodeModifier::CreateGestureRecognizer(others[index]);
738 }
739 ArkUIParallelInnerGestureEvent parallelInnerGestureEvent;
740 parallelInnerGestureEvent.current = currentArkUIGestureRecognizer;
741 parallelInnerGestureEvent.responseLinkRecognizer = othersArkUIGestureRecognizer;
742 parallelInnerGestureEvent.userData = userData;
743 parallelInnerGestureEvent.count = count;
744 auto* result = parallelInnerGesture(¶llelInnerGestureEvent);
745 if (!result || !result->recognizer) {
746 return nullptr;
747 }
748 delete[] othersArkUIGestureRecognizer;
749 return AceType::Claim(reinterpret_cast<NG::NGGestureRecognizer*>(result->recognizer));
750 };
751 ViewAbstract::SetShouldBuiltInRecognizerParallelWith(frameNode, std::move(parallelInnerGestureTo));
752 return ERROR_CODE_NO_ERROR;
753 }
754
setGestureRecognizerEnabled(ArkUIGestureRecognizer * recognizer,bool enabled)755 ArkUI_Int32 setGestureRecognizerEnabled(ArkUIGestureRecognizer* recognizer, bool enabled)
756 {
757 auto* gestureRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
758 CHECK_NULL_RETURN(gestureRecognizer, ERROR_CODE_PARAM_INVALID);
759 gestureRecognizer->SetEnabled(enabled);
760 return ERROR_CODE_NO_ERROR;
761 }
762
setGestureRecognizerLimitFingerCount(ArkUIGesture * gesture,bool limitFingerCount)763 ArkUI_Int32 setGestureRecognizerLimitFingerCount(ArkUIGesture* gesture, bool limitFingerCount)
764 {
765 auto gestureForLimitFinger = Referenced::Claim(reinterpret_cast<Gesture*>(gesture));
766 CHECK_NULL_RETURN(gestureForLimitFinger, ERROR_CODE_PARAM_INVALID);
767 gestureForLimitFinger->SetLimitFingerCount(limitFingerCount);
768 return ERROR_CODE_NO_ERROR;
769 }
770
getGestureRecognizerEnabled(ArkUIGestureRecognizer * recognizer)771 ArkUI_Bool getGestureRecognizerEnabled(ArkUIGestureRecognizer* recognizer)
772 {
773 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
774 CHECK_NULL_RETURN(rawRecognizer, false);
775 auto gestureRecognizer = AceType::Claim(rawRecognizer);
776 return gestureRecognizer->IsEnabled();
777 }
778
getGestureRecognizerState(ArkUIGestureRecognizer * recognizer,ArkUIGestureRecognizerState * state)779 ArkUI_Int32 getGestureRecognizerState(ArkUIGestureRecognizer* recognizer, ArkUIGestureRecognizerState* state)
780 {
781 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
782 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
783 auto gestureRecognizer = AceType::Claim(rawRecognizer);
784 switch (gestureRecognizer->GetRefereeState()) {
785 case NG::RefereeState::READY:
786 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_READY;
787 return ERROR_CODE_NO_ERROR;
788 case NG::RefereeState::DETECTING:
789 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_DETECTING;
790 return ERROR_CODE_NO_ERROR;
791 case NG::RefereeState::PENDING:
792 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_PENDING;
793 return ERROR_CODE_NO_ERROR;
794 case NG::RefereeState::PENDING_BLOCKED:
795 case NG::RefereeState::SUCCEED_BLOCKED:
796 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_BLOCKED;
797 return ERROR_CODE_NO_ERROR;
798 case NG::RefereeState::SUCCEED:
799 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_SUCCESSFUL;
800 return ERROR_CODE_NO_ERROR;
801 case NG::RefereeState::FAIL:
802 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_FAILED;
803 return ERROR_CODE_NO_ERROR;
804 default:
805 *state = ArkUIGestureRecognizerState::RECOGNIZER_STATE_READY;
806 return ERROR_CODE_PARAM_INVALID;
807 }
808 }
809
gestureEventTargetInfoIsScrollBegin(ArkUIGestureEventTargetInfo * info,bool * ret)810 ArkUI_Int32 gestureEventTargetInfoIsScrollBegin(ArkUIGestureEventTargetInfo* info, bool* ret)
811 {
812 auto frameNode = AceType::Claim(reinterpret_cast<NG::FrameNode*>(info->uiNode));
813 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
814 auto scrollablePattern = frameNode->GetPattern<NG::ScrollablePattern>();
815 if (scrollablePattern) {
816 *ret = scrollablePattern->IsAtTop();
817 return ERROR_CODE_NO_ERROR;
818 }
819 auto swiperPattern = frameNode->GetPattern<NG::SwiperPattern>();
820 if (swiperPattern) {
821 *ret = swiperPattern->IsAtStart();
822 return ERROR_CODE_NO_ERROR;
823 }
824 return ERROR_CODE_NON_SCROLLABLE_CONTAINER;
825 }
826
gestureEventTargetInfoIsScrollEnd(ArkUIGestureEventTargetInfo * info,bool * ret)827 ArkUI_Int32 gestureEventTargetInfoIsScrollEnd(ArkUIGestureEventTargetInfo* info, bool* ret)
828 {
829 auto frameNode = AceType::Claim(reinterpret_cast<NG::FrameNode*>(info->uiNode));
830 CHECK_NULL_RETURN(frameNode, ERROR_CODE_PARAM_INVALID);
831 auto scrollablePattern = frameNode->GetPattern<NG::ScrollablePattern>();
832 if (scrollablePattern) {
833 *ret = scrollablePattern->IsAtBottom();
834 return ERROR_CODE_NO_ERROR;
835 }
836 auto swiperPattern = frameNode->GetPattern<NG::SwiperPattern>();
837 if (swiperPattern) {
838 *ret = swiperPattern->IsAtEnd();
839 return ERROR_CODE_NO_ERROR;
840 }
841 return ERROR_CODE_NON_SCROLLABLE_CONTAINER;
842 }
843
getPanGestureDirectionMask(ArkUIGestureRecognizer * recognizer,ArkUIGestureDirection * direction)844 ArkUI_Int32 getPanGestureDirectionMask(ArkUIGestureRecognizer* recognizer, ArkUIGestureDirection* direction)
845 {
846 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
847 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
848 auto gestureRecognizer = AceType::Claim(rawRecognizer);
849 auto panRecognizer = AceType::DynamicCast<PanRecognizer>(gestureRecognizer);
850 CHECK_NULL_RETURN(panRecognizer, ERROR_CODE_PARAM_INVALID);
851 *direction = static_cast<ArkUIGestureDirection>(panRecognizer->GetDirection().type);
852 return ERROR_CODE_NO_ERROR;
853 }
854
isBuiltInGesture(ArkUIGestureRecognizer * recognizer)855 ArkUI_Bool isBuiltInGesture(ArkUIGestureRecognizer* recognizer)
856 {
857 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
858 CHECK_NULL_RETURN(rawRecognizer, false);
859 auto gestureRecognizer = AceType::Claim(rawRecognizer);
860 return gestureRecognizer->IsSystemGesture();
861 }
862
getGestureTag(ArkUIGestureRecognizer * recognizer,char * buffer,ArkUI_Int32 bufferSize,ArkUI_Int32 * result)863 ArkUI_Int32 getGestureTag(ArkUIGestureRecognizer* recognizer, char* buffer, ArkUI_Int32 bufferSize, ArkUI_Int32* result)
864 {
865 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
866 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
867 auto gestureRecognizer = AceType::Claim(rawRecognizer);
868 auto gestureInfo = gestureRecognizer->GetGestureInfo();
869 CHECK_NULL_RETURN(gestureInfo, ERROR_CODE_PARAM_INVALID);
870 auto gestureTag = gestureInfo->GetTag();
871 CHECK_NULL_RETURN(gestureTag.has_value(), ERROR_CODE_PARAM_INVALID);
872 auto actualSize = static_cast<int32_t>(gestureTag.value().size());
873 *result = actualSize;
874 if (actualSize > bufferSize - 1) {
875 return ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
876 }
877 auto count = snprintf_s(buffer, bufferSize, bufferSize - 1, "%s", gestureTag.value().c_str());
878 if (count < 0) {
879 return ERROR_CODE_PARAM_INVALID;
880 }
881 return ERROR_CODE_NO_ERROR;
882 }
883
getGestureBindNodeId(ArkUIGestureRecognizer * recognizer,char * nodeId,ArkUI_Int32 size,ArkUI_Int32 * result)884 ArkUI_Int32 getGestureBindNodeId(
885 ArkUIGestureRecognizer* recognizer, char* nodeId, ArkUI_Int32 size, ArkUI_Int32* result)
886 {
887 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
888 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
889 auto gestureRecognizer = AceType::Claim(rawRecognizer);
890 auto attachNode = gestureRecognizer->GetAttachedNode().Upgrade();
891 CHECK_NULL_RETURN(attachNode, ERROR_CODE_PARAM_INVALID);
892 auto inspectorId = attachNode->GetInspectorIdValue("");
893 auto actualSize = static_cast<int32_t>(inspectorId.size());
894 *result = actualSize;
895 if (actualSize > size - 1) {
896 return ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH;
897 }
898 auto count = snprintf_s(nodeId, size, size - 1, "%s", inspectorId.c_str());
899 if (count < 0) {
900 return ERROR_CODE_PARAM_INVALID;
901 }
902 return ERROR_CODE_NO_ERROR;
903 }
904
isGestureRecognizerValid(ArkUIGestureRecognizer * recognizer)905 ArkUI_Bool isGestureRecognizerValid(ArkUIGestureRecognizer* recognizer)
906 {
907 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
908 CHECK_NULL_RETURN(rawRecognizer, false);
909 auto gestureRecognizer = AceType::Claim(rawRecognizer);
910 return gestureRecognizer->IsInResponseLinkRecognizers();
911 }
912
setArkUIGestureRecognizerDisposeNotify(ArkUIGestureRecognizer * recognizer,void * userData,void (* callback)(ArkUIGestureRecognizer * recognizer,void * userData))913 ArkUI_Int32 setArkUIGestureRecognizerDisposeNotify(ArkUIGestureRecognizer* recognizer, void* userData,
914 void (*callback)(ArkUIGestureRecognizer* recognizer, void* userData))
915 {
916 auto* rawRecognizer = reinterpret_cast<NG::NGGestureRecognizer*>(recognizer->recognizer);
917 CHECK_NULL_RETURN(rawRecognizer, ERROR_CODE_PARAM_INVALID);
918 auto gestureRecognizer = AceType::Claim(rawRecognizer);
919 auto disposeNotify = [userData, callback](void* recognizer) {
920 auto* arkuiGestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(recognizer);
921 callback(arkuiGestureRecognizer, userData);
922 };
923 gestureRecognizer->SetDisposeNotifyCallback(std::move(disposeNotify));
924 return ERROR_CODE_NO_ERROR;
925 }
926
927 namespace NodeModifier {
GetGestureModifier()928 const ArkUIGestureModifier* GetGestureModifier()
929 {
930 static const ArkUIGestureModifier modifier = {
931 createTapGesture,
932 createTapGestureWithDistanceThreshold,
933 createLongPressGesture,
934 createPanGesture,
935 createPinchGesture,
936 createRotationGesture,
937 createSwipeGesture,
938 createSwipeGestureByModifier,
939 createGestureGroup,
940 addGestureToGestureGroup,
941 removeGestureFromGestureGroup,
942 dispose,
943 registerGestureEvent,
944 addGestureToNode,
945 removeGestureFromNode,
946 removeGestureFromNodeByTag,
947 clearGestures,
948 setGestureInterrupterToNode,
949 setInnerGestureParallelTo,
950 setGestureRecognizerEnabled,
951 setGestureRecognizerLimitFingerCount,
952 getGestureRecognizerEnabled,
953 getGestureRecognizerState,
954 gestureEventTargetInfoIsScrollBegin,
955 gestureEventTargetInfoIsScrollEnd,
956 getPanGestureDirectionMask,
957 isBuiltInGesture,
958 getGestureTag,
959 getGestureBindNodeId,
960 isGestureRecognizerValid,
961 setArkUIGestureRecognizerDisposeNotify,
962 addGestureToGestureGroupWithRefCountDecrease,
963 addGestureToNodeWithRefCountDecrease,
964 touchRecognizerGetNodeHandle,
965 touchRecognizerCancelTouch,
966 };
967 return &modifier;
968 }
969
GetCJUIGestureModifier()970 const CJUIGestureModifier* GetCJUIGestureModifier()
971 {
972 static const CJUIGestureModifier modifier = {
973 createTapGesture,
974 createLongPressGesture,
975 createPanGesture,
976 createPinchGesture,
977 createRotationGesture,
978 createSwipeGesture,
979 createSwipeGestureByModifier,
980 createGestureGroup,
981 addGestureToGestureGroup,
982 removeGestureFromGestureGroup,
983 dispose,
984 registerGestureEvent,
985 addGestureToNode,
986 removeGestureFromNode,
987 removeGestureFromNodeByTag,
988 clearGestures,
989 setGestureInterrupterToNode,
990 };
991 return &modifier;
992 }
993
CreateGestureRecognizer(const RefPtr<NG::NGGestureRecognizer> & recognizer)994 ArkUIGestureRecognizer* CreateGestureRecognizer(const RefPtr<NG::NGGestureRecognizer>& recognizer)
995 {
996 CHECK_NULL_RETURN(recognizer, nullptr);
997 ArkUIGestureRecognizer* arkUIGestureRecognizer;
998 auto gestureInfo = recognizer->GetGestureInfo();
999 CHECK_NULL_RETURN(gestureInfo, nullptr);
1000 auto* userData = gestureInfo->GetUserData();
1001 if (userData) {
1002 arkUIGestureRecognizer = reinterpret_cast<ArkUIGestureRecognizer*>(userData);
1003 } else {
1004 arkUIGestureRecognizer = new ArkUIGestureRecognizer();
1005 arkUIGestureRecognizer->capi = false;
1006 gestureInfo->SetUserData(arkUIGestureRecognizer);
1007 }
1008 arkUIGestureRecognizer->type = static_cast<int32_t>(gestureInfo->GetRecognizerType());
1009 arkUIGestureRecognizer->recognizer = reinterpret_cast<void*>(AceType::RawPtr(recognizer));
1010 auto attachNode = recognizer->GetAttachedNode().Upgrade();
1011 if (attachNode) {
1012 arkUIGestureRecognizer->targetInfo.uiNode = reinterpret_cast<void*>(AceType::RawPtr(attachNode));
1013 }
1014 gestureInfo->SetIsCapi(arkUIGestureRecognizer->capi);
1015 gestureInfo->SetDisposeJSRecognizerInfoFunc([arkUIGestureRecognizer]() {
1016 delete arkUIGestureRecognizer;
1017 });
1018 return arkUIGestureRecognizer;
1019 }
1020 } // namespace NodeModifier
1021 } // namespace OHOS::Ace::NG
1022