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 "interfaces/native/event/ui_input_event_impl.h"
17
18 #include "core/event/touch_event.h"
19 #include "interfaces/native/node/event_converter.h"
20 #include "interfaces/native/node/node_model.h"
21 #include "base/error/error_code.h"
22 #include "frameworks/core/common/ace_application_info.h"
23
24 #ifdef __cplusplus
25 extern "C" {
26 #endif
27
28 thread_local ArkUI_ErrorCode g_latestEventStatus = ARKUI_ERROR_CODE_NO_ERROR;
29 thread_local ArkUI_ErrorCode g_scenarioSupportCheckResult = ARKUI_ERROR_CODE_NO_ERROR;
30
isCurrentCTouchEventParamValid(const ArkUITouchEvent * touchEvent,uint32_t pointerIndex)31 bool isCurrentCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t pointerIndex)
32 {
33 if (!touchEvent) {
34 return false;
35 }
36 if ((pointerIndex < 0 || pointerIndex >= touchEvent->touchPointSize) ||
37 !(touchEvent->touchPointes)) {
38 return false;
39 }
40 return true;
41 }
42
isHistoryCTouchEventParamValid(const ArkUITouchEvent * touchEvent,uint32_t historyIndex,uint32_t pointerIndex)43 bool isHistoryCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t historyIndex, uint32_t pointerIndex)
44 {
45 if (!touchEvent) {
46 return false;
47 }
48 if ((historyIndex < 0 || historyIndex >= touchEvent->historySize) ||
49 !touchEvent->historyEvents) {
50 return false;
51 }
52 if ((pointerIndex < 0 || pointerIndex >= touchEvent->historyEvents[historyIndex].touchPointSize) ||
53 !(touchEvent->historyEvents[historyIndex].touchPointes)) {
54 return false;
55 }
56 return true;
57 }
58
OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent * event)59 int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
60 {
61 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
62 S_NODE_ON_KEY_EVENT | S_NODE_ON_KEY_PRE_IME | S_NODE_ON_FOCUS_AXIS |
63 S_NODE_DISPATCH_KEY_EVENT | S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE |
64 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
65 S_GESTURE_CLICK_EVENT | S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
66 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
67 if (!event) {
68 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
69 }
70 if (event->apiVersion >= static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY)) {
71 RETURN_RET_WITH_STATUS_CHECK(event->inputType, ARKUI_ERROR_CODE_NO_ERROR);
72 }
73 switch (event->eventTypeId) {
74 case C_KEY_EVENT_ID: {
75 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
76 }
77 case C_FOCUS_AXIS_EVENT_ID: {
78 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
79 }
80 case C_CLICK_EVENT_ID: {
81 if (event->inputType == ARKUI_UIINPUTEVENT_TYPE_KEY) {
82 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_NO_ERROR);
83 }
84 break;
85 }
86 default: {
87 break;
88 }
89 }
90 RETURN_RET_WITH_STATUS_CHECK(event->inputType, ARKUI_ERROR_CODE_NO_ERROR);
91 }
92
HandleCTouchEventAction(const ArkUI_UIInputEvent * event)93 int32_t HandleCTouchEventAction(const ArkUI_UIInputEvent* event)
94 {
95 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
96 if (!touchEvent) {
97 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
98 }
99 RETURN_RET_WITH_STATUS_CHECK(
100 OHOS::Ace::NodeModel::ConvertToCTouchActionType(touchEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
101 }
102
HandleCMouseEventAction(const ArkUI_UIInputEvent * event)103 int32_t HandleCMouseEventAction(const ArkUI_UIInputEvent* event)
104 {
105 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
106 if (!mouseEvent) {
107 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
108 }
109 RETURN_RET_WITH_STATUS_CHECK(
110 OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
111 }
112
HandleCAxisEventAction(const ArkUI_UIInputEvent * event)113 int32_t HandleCAxisEventAction(const ArkUI_UIInputEvent* event)
114 {
115 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
116 if (!axisEvent) {
117 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
118 }
119 RETURN_RET_WITH_STATUS_CHECK(
120 OHOS::Ace::NodeModel::ConvertToCAxisActionType(axisEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
121 }
122
HandleCClickEventAction(const ArkUI_UIInputEvent * event)123 int32_t HandleCClickEventAction(const ArkUI_UIInputEvent* event)
124 {
125 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
126 if (!keyEvent) {
127 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
128 }
129 RETURN_RET_WITH_STATUS_CHECK(
130 OHOS::Ace::NodeModel::ConvertToCKeyActionType(keyEvent->type), ARKUI_ERROR_CODE_NO_ERROR);
131 }
132
HandleTouchEventAction(const ArkUI_UIInputEvent * event)133 int32_t HandleTouchEventAction(const ArkUI_UIInputEvent* event)
134 {
135 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
136 if (!touchEvent) {
137 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
138 }
139 RETURN_RET_WITH_STATUS_CHECK(
140 OHOS::Ace::NodeModel::ConvertToCTouchActionType(static_cast<int32_t>(touchEvent->type)),
141 ARKUI_ERROR_CODE_NO_ERROR);
142 }
143
HandleAxisEventAction(const ArkUI_UIInputEvent * event)144 int32_t HandleAxisEventAction(const ArkUI_UIInputEvent* event)
145 {
146 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
147 if (!axisEvent) {
148 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
149 }
150 RETURN_RET_WITH_STATUS_CHECK(
151 OHOS::Ace::NodeModel::ConvertToCAxisActionType(static_cast<int32_t>(axisEvent->action)),
152 ARKUI_ERROR_CODE_NO_ERROR);
153 }
154
OH_ArkUI_UIInputEvent_GetAction_Ext(const ArkUI_UIInputEvent * event)155 int32_t OH_ArkUI_UIInputEvent_GetAction_Ext(const ArkUI_UIInputEvent* event)
156 {
157 if (!event) {
158 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
159 }
160 std::map<ArkUIEventTypeId, std::function<int32_t(ArkUI_UIInputEvent*)>> eventHandlers = {
161 { C_TOUCH_EVENT_ID, HandleCTouchEventAction },
162 { C_MOUSE_EVENT_ID, HandleCMouseEventAction },
163 { C_AXIS_EVENT_ID, HandleCAxisEventAction },
164 { C_CLICK_EVENT_ID, HandleCClickEventAction },
165 { TOUCH_EVENT_ID, HandleTouchEventAction},
166 { AXIS_EVENT_ID, HandleAxisEventAction },
167 };
168 auto it = eventHandlers.find(event->eventTypeId);
169 if (it != eventHandlers.end()) {
170 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
171 return it->second(inputEvent);
172 }
173 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
174 }
175
OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent * event)176 int32_t OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent* event)
177 {
178 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
179 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
180 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_GESTURE_CLICK_EVENT |
181 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
182 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
183 if (!event) {
184 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
185 }
186 if (event->apiVersion >= static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY)) {
187 return OH_ArkUI_UIInputEvent_GetAction_Ext(event);
188 }
189 switch (event->eventTypeId) {
190 case C_TOUCH_EVENT_ID: {
191 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
192 if (!touchEvent) {
193 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
194 }
195 RETURN_RET_WITH_STATUS_CHECK(
196 OHOS::Ace::NodeModel::ConvertToCTouchActionType(touchEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
197 }
198 case C_MOUSE_EVENT_ID: {
199 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
200 if (!mouseEvent) {
201 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
202 }
203 RETURN_RET_WITH_STATUS_CHECK(
204 OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
205 }
206 default:
207 break;
208 }
209 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
210 }
211
HandleCTouchEventSourceType(const ArkUI_UIInputEvent * event)212 int32_t HandleCTouchEventSourceType(const ArkUI_UIInputEvent* event)
213 {
214 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
215 if (!touchEvent) {
216 RETURN_RET_WITH_STATUS_CHECK(
217 static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
218 }
219 RETURN_RET_WITH_STATUS_CHECK(touchEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
220 }
221
HandleCClickEventSourceType(const ArkUI_UIInputEvent * event)222 int32_t HandleCClickEventSourceType(const ArkUI_UIInputEvent* event)
223 {
224 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
225 if (!clickEvent) {
226 RETURN_RET_WITH_STATUS_CHECK(
227 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
228 }
229 RETURN_RET_WITH_STATUS_CHECK(clickEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
230 }
231
HandleCMouseEventSourceType(const ArkUI_UIInputEvent * event)232 int32_t HandleCMouseEventSourceType(const ArkUI_UIInputEvent* event)
233 {
234 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
235 if (!mouseEvent) {
236 RETURN_RET_WITH_STATUS_CHECK(
237 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
238 }
239 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
240 }
241
HandleCAxisEventSourceType(const ArkUI_UIInputEvent * event)242 int32_t HandleCAxisEventSourceType(const ArkUI_UIInputEvent* event)
243 {
244 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
245 if (!axisEvent) {
246 RETURN_RET_WITH_STATUS_CHECK(
247 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
248 }
249 RETURN_RET_WITH_STATUS_CHECK(axisEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
250 }
251
HandleCFocusAxisEventSourceType(const ArkUI_UIInputEvent * event)252 int32_t HandleCFocusAxisEventSourceType(const ArkUI_UIInputEvent* event)
253 {
254 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
255 if (!focusAxisEvent) {
256 RETURN_RET_WITH_STATUS_CHECK(
257 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
258 }
259 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
260 }
261
HandleCHoverEventSourceType(const ArkUI_UIInputEvent * event)262 int32_t HandleCHoverEventSourceType(const ArkUI_UIInputEvent* event)
263 {
264 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
265 if (!hoverEvent) {
266 RETURN_RET_WITH_STATUS_CHECK(
267 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
268 }
269 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->sourceType, ARKUI_ERROR_CODE_NO_ERROR);
270 }
271
HandleAxisEventSourceType(const ArkUI_UIInputEvent * event)272 int32_t HandleAxisEventSourceType(const ArkUI_UIInputEvent* event)
273 {
274 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
275 if (!axisEvent) {
276 RETURN_RET_WITH_STATUS_CHECK(
277 static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
278 }
279 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(axisEvent->sourceType), ARKUI_ERROR_CODE_NO_ERROR);
280 }
281
OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent * event)282 int32_t OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent* event)
283 {
284 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
285 S_NODE_ON_FOCUS_AXIS | S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT |
286 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
287 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_NXC_DISPATCH_AXIS_EVENT;
288 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
289 if (!event) {
290 RETURN_RET_WITH_STATUS_CHECK(
291 static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
292 }
293 std::map<ArkUIEventTypeId, std::function<int32_t(ArkUI_UIInputEvent*)>> eventHandlers = {
294 { C_TOUCH_EVENT_ID, HandleCTouchEventSourceType },
295 { C_MOUSE_EVENT_ID, HandleCMouseEventSourceType },
296 { C_AXIS_EVENT_ID, HandleCAxisEventSourceType },
297 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventSourceType },
298 { C_HOVER_EVENT_ID, HandleCHoverEventSourceType },
299 { C_CLICK_EVENT_ID, HandleCClickEventSourceType },
300 { AXIS_EVENT_ID, HandleAxisEventSourceType },
301 };
302 auto it = eventHandlers.find(event->eventTypeId);
303 if (it != eventHandlers.end()) {
304 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
305 return it->second(inputEvent);
306 }
307 RETURN_RET_WITH_STATUS_CHECK(
308 static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN), ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
309 }
310
HandleCTouchEventToolType(const ArkUI_UIInputEvent * event)311 int32_t HandleCTouchEventToolType(const ArkUI_UIInputEvent* event)
312 {
313 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
314 if (!touchEvent) {
315 RETURN_RET_WITH_STATUS_CHECK(
316 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
317 }
318 RETURN_RET_WITH_STATUS_CHECK(
319 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(touchEvent->actionTouchPoint.toolType),
320 ARKUI_ERROR_CODE_NO_ERROR);
321 }
322
HandleCMouseEventToolType(const ArkUI_UIInputEvent * event)323 int32_t HandleCMouseEventToolType(const ArkUI_UIInputEvent* event)
324 {
325 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
326 if (!mouseEvent) {
327 RETURN_RET_WITH_STATUS_CHECK(
328 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
329 }
330 RETURN_RET_WITH_STATUS_CHECK(
331 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(mouseEvent->actionTouchPoint.toolType),
332 ARKUI_ERROR_CODE_NO_ERROR);
333 }
334
HandleCHoverEventToolType(const ArkUI_UIInputEvent * event)335 int32_t HandleCHoverEventToolType(const ArkUI_UIInputEvent* event)
336 {
337 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
338 if (!hoverEvent) {
339 RETURN_RET_WITH_STATUS_CHECK(
340 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
341 }
342 RETURN_RET_WITH_STATUS_CHECK(
343 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(hoverEvent->toolType), ARKUI_ERROR_CODE_NO_ERROR);
344 }
345
HandleCClickEventToolType(const ArkUI_UIInputEvent * event)346 int32_t HandleCClickEventToolType(const ArkUI_UIInputEvent* event)
347 {
348 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
349 if (!clickEvent) {
350 RETURN_RET_WITH_STATUS_CHECK(
351 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
352 }
353 RETURN_RET_WITH_STATUS_CHECK(
354 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(clickEvent->toolType), ARKUI_ERROR_CODE_NO_ERROR);
355 }
356
HandleCAxisEventToolType(const ArkUI_UIInputEvent * event)357 int32_t HandleCAxisEventToolType(const ArkUI_UIInputEvent* event)
358 {
359 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
360 if (!axisEvent) {
361 RETURN_RET_WITH_STATUS_CHECK(
362 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
363 }
364 RETURN_RET_WITH_STATUS_CHECK(
365 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(axisEvent->actionTouchPoint.toolType),
366 ARKUI_ERROR_CODE_NO_ERROR);
367 }
368
HandleCFocusAxisEventToolType(const ArkUI_UIInputEvent * event)369 int32_t HandleCFocusAxisEventToolType(const ArkUI_UIInputEvent* event)
370 {
371 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
372 if (!focusAxisEvent) {
373 RETURN_RET_WITH_STATUS_CHECK(
374 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
375 }
376 RETURN_RET_WITH_STATUS_CHECK(
377 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(focusAxisEvent->toolType), ARKUI_ERROR_CODE_NO_ERROR);
378 }
379
HandleAxisEventToolType(const ArkUI_UIInputEvent * event)380 int32_t HandleAxisEventToolType(const ArkUI_UIInputEvent* event)
381 {
382 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
383 if (!axisEvent) {
384 RETURN_RET_WITH_STATUS_CHECK(
385 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
386 }
387 RETURN_RET_WITH_STATUS_CHECK(
388 OHOS::Ace::NodeModel::ConvertToCInputEventToolType(static_cast<int32_t>(axisEvent->sourceTool)),
389 ARKUI_ERROR_CODE_NO_ERROR);
390 }
391
OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent * event)392 int32_t OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent* event)
393 {
394 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
395 S_NODE_ON_FOCUS_AXIS | S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT |
396 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
397 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_NXC_DISPATCH_AXIS_EVENT;
398 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
399 if (!event) {
400 RETURN_RET_WITH_STATUS_CHECK(
401 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_CODE_PARAM_INVALID);
402 }
403 std::map<ArkUIEventTypeId, std::function<int32_t(ArkUI_UIInputEvent*)>> eventHandlers = {
404 { C_TOUCH_EVENT_ID, HandleCTouchEventToolType },
405 { C_MOUSE_EVENT_ID, HandleCMouseEventToolType },
406 { C_AXIS_EVENT_ID, HandleCAxisEventToolType },
407 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventToolType },
408 { C_HOVER_EVENT_ID, HandleCHoverEventToolType },
409 { C_CLICK_EVENT_ID, HandleCClickEventToolType },
410 { AXIS_EVENT_ID, HandleAxisEventToolType },
411 };
412 auto it = eventHandlers.find(event->eventTypeId);
413 if (it != eventHandlers.end()) {
414 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
415 return it->second(inputEvent);
416 }
417 RETURN_RET_WITH_STATUS_CHECK(
418 static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN), ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
419 }
420
HandleCTouchEvent(ArkUI_UIInputEvent * event)421 int64_t HandleCTouchEvent(ArkUI_UIInputEvent* event)
422 {
423 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
424 if (!touchEvent) {
425 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
426 }
427 RETURN_RET_WITH_STATUS_CHECK(touchEvent->timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
428 }
429
HandleTouchEvent(ArkUI_UIInputEvent * event)430 int64_t HandleTouchEvent(ArkUI_UIInputEvent* event)
431 {
432 const auto* uiEvent = reinterpret_cast<const OHOS::Ace::PointerEvent*>(event->inputEvent);
433 if (!uiEvent) {
434 LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
435 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
436 }
437 RETURN_RET_WITH_STATUS_CHECK(uiEvent->time.time_since_epoch().count(), ARKUI_ERROR_CODE_NO_ERROR);
438 }
439
HandleAxisEvent(ArkUI_UIInputEvent * event)440 int64_t HandleAxisEvent(ArkUI_UIInputEvent* event)
441 {
442 const auto* uiEvent = reinterpret_cast<const OHOS::Ace::PointerEvent*>(event->inputEvent);
443 if (!uiEvent) {
444 LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
445 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
446 }
447 RETURN_RET_WITH_STATUS_CHECK(uiEvent->time.time_since_epoch().count(), ARKUI_ERROR_CODE_NO_ERROR);
448 }
449
HandleCMouseEvent(ArkUI_UIInputEvent * event)450 int64_t HandleCMouseEvent(ArkUI_UIInputEvent* event)
451 {
452 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
453 if (!mouseEvent) {
454 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
455 }
456 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
457 }
458
HandleCAxisEvent(ArkUI_UIInputEvent * event)459 int64_t HandleCAxisEvent(ArkUI_UIInputEvent* event)
460 {
461 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
462 if (!axisEvent) {
463 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
464 }
465 RETURN_RET_WITH_STATUS_CHECK(axisEvent->timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
466 }
467
HandleCKeyEvent(ArkUI_UIInputEvent * event)468 int64_t HandleCKeyEvent(ArkUI_UIInputEvent* event)
469 {
470 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
471 if (!keyEvent) {
472 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
473 }
474 RETURN_RET_WITH_STATUS_CHECK(keyEvent->timestamp, ARKUI_ERROR_CODE_NO_ERROR);
475 }
476
HandleCFocusAxisEvent(ArkUI_UIInputEvent * event)477 int64_t HandleCFocusAxisEvent(ArkUI_UIInputEvent* event)
478 {
479 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
480 if (!focusAxisEvent) {
481 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
482 }
483 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
484 }
485
HandleCHoverEventTimestamp(ArkUI_UIInputEvent * event)486 int64_t HandleCHoverEventTimestamp(ArkUI_UIInputEvent* event)
487 {
488 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
489 if (!hoverEvent) {
490 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
491 }
492 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
493 }
494
HandleCClickEventTimestamp(ArkUI_UIInputEvent * event)495 int64_t HandleCClickEventTimestamp(ArkUI_UIInputEvent* event)
496 {
497 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
498 if (!clickEvent) {
499 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
500 }
501 RETURN_RET_WITH_STATUS_CHECK(clickEvent->timestamp, ARKUI_ERROR_CODE_NO_ERROR);
502 }
503
OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent * event)504 int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)
505 {
506 const int32_t supportedScenario =
507 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE | S_NODE_ON_KEY_EVENT | S_NODE_ON_KEY_PRE_IME |
508 S_NODE_ON_FOCUS_AXIS | S_NODE_DISPATCH_KEY_EVENT | S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT |
509 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT |
510 S_GESTURE_MOUSE_EVENT | S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
511 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
512 if (!event) {
513 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
514 }
515 std::map<ArkUIEventTypeId, std::function<int64_t(ArkUI_UIInputEvent*)>> eventHandlers = {
516 {C_TOUCH_EVENT_ID, HandleCTouchEvent},
517 {TOUCH_EVENT_ID, HandleTouchEvent},
518 {AXIS_EVENT_ID, HandleAxisEvent},
519 {C_MOUSE_EVENT_ID, HandleCMouseEvent},
520 {C_AXIS_EVENT_ID, HandleCAxisEvent},
521 {C_KEY_EVENT_ID, HandleCKeyEvent},
522 {C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEvent},
523 {C_HOVER_EVENT_ID, HandleCHoverEventTimestamp},
524 {C_CLICK_EVENT_ID, HandleCClickEventTimestamp},
525 };
526 auto it = eventHandlers.find(event->eventTypeId);
527 if (it != eventHandlers.end()) {
528 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
529 return it->second(inputEvent);
530 }
531 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
532 }
533
GetCKeyEventDeviceId(ArkUI_UIInputEvent * event)534 int32_t GetCKeyEventDeviceId(ArkUI_UIInputEvent* event)
535 {
536 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
537 if (!keyEvent) {
538 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
539 }
540 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(keyEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
541 }
542
GetCFocusAxisEventDeviceId(ArkUI_UIInputEvent * event)543 int32_t GetCFocusAxisEventDeviceId(ArkUI_UIInputEvent* event)
544 {
545 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
546 if (!focusAxisEvent) {
547 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
548 }
549 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(focusAxisEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
550 }
551
GetCMouseEventDeviceId(ArkUI_UIInputEvent * event)552 int32_t GetCMouseEventDeviceId(ArkUI_UIInputEvent* event)
553 {
554 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
555 if (!mouseEvent) {
556 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
557 }
558 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(mouseEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
559 }
560
GetCTouchEventDeviceId(ArkUI_UIInputEvent * event)561 int32_t GetCTouchEventDeviceId(ArkUI_UIInputEvent* event)
562 {
563 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
564 if (!touchEvent) {
565 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
566 }
567 if (event->apiVersion < static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY) &&
568 touchEvent->subKind == ON_TOUCH_INTERCEPT) {
569 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
570 }
571 if (event->apiVersion < static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY) &&
572 touchEvent->subKind == ON_HOVER_MOVE) {
573 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
574 }
575 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(touchEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
576 }
577
GetCHoverEventDeviceId(ArkUI_UIInputEvent * event)578 int32_t GetCHoverEventDeviceId(ArkUI_UIInputEvent* event)
579 {
580 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
581 if (!hoverEvent) {
582 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
583 }
584 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(hoverEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
585 }
586
GetCClickEventDeviceId(ArkUI_UIInputEvent * event)587 int32_t GetCClickEventDeviceId(ArkUI_UIInputEvent* event)
588 {
589 if (event->inputType == ARKUI_UIINPUTEVENT_TYPE_KEY) {
590 if (event->apiVersion >= static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY)) {
591 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
592 if (!keyEvent) {
593 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
594 }
595 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(keyEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
596 }
597 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_NO_ERROR);
598 }
599 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
600 if (!clickEvent) {
601 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
602 }
603 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(clickEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
604 }
605
GetCAxisEventDeviceId(ArkUI_UIInputEvent * event)606 int32_t GetCAxisEventDeviceId(ArkUI_UIInputEvent* event)
607 {
608 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
609 if (!axisEvent) {
610 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
611 }
612 if (axisEvent->subKind == ON_AXIS &&
613 event->apiVersion < static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY)) {
614 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
615 }
616 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(axisEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
617 }
618
GetAxisEventDeviceId(ArkUI_UIInputEvent * event)619 int32_t GetAxisEventDeviceId(ArkUI_UIInputEvent* event)
620 {
621 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
622 if (!axisEvent) {
623 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
624 }
625 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(axisEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
626 }
627
GetTouchEventDeviceId(ArkUI_UIInputEvent * event)628 int32_t GetTouchEventDeviceId(ArkUI_UIInputEvent* event)
629 {
630 if (event->apiVersion < static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY)) {
631 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
632 }
633 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
634 if (!touchEvent) {
635 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
636 }
637 RETURN_RET_WITH_STATUS_CHECK(static_cast<int32_t>(touchEvent->deviceId), ARKUI_ERROR_CODE_NO_ERROR);
638 }
639
OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent * event)640 int32_t OH_ArkUI_UIInputEvent_GetDeviceId(const ArkUI_UIInputEvent *event)
641 {
642 const int32_t supportedScenario =
643 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE | S_NODE_ON_KEY_EVENT | S_NODE_ON_KEY_PRE_IME |
644 S_NODE_ON_FOCUS_AXIS | S_NODE_DISPATCH_KEY_EVENT | S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT |
645 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT |
646 S_GESTURE_MOUSE_EVENT | S_GESTURE_CLICK_EVENT | S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
647 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
648 if (!event) {
649 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
650 }
651 std::map<ArkUIEventTypeId, std::function<int64_t(ArkUI_UIInputEvent*)>> eventHandlers = {
652 {C_KEY_EVENT_ID, GetCKeyEventDeviceId},
653 {C_FOCUS_AXIS_EVENT_ID, GetCFocusAxisEventDeviceId},
654 {C_MOUSE_EVENT_ID, GetCMouseEventDeviceId},
655 {C_TOUCH_EVENT_ID, GetCTouchEventDeviceId},
656 {C_HOVER_EVENT_ID, GetCHoverEventDeviceId},
657 {C_CLICK_EVENT_ID, GetCClickEventDeviceId},
658 {C_AXIS_EVENT_ID, GetCAxisEventDeviceId },
659 {AXIS_EVENT_ID, GetAxisEventDeviceId },
660 {TOUCH_EVENT_ID, GetTouchEventDeviceId },
661 };
662 auto iter = eventHandlers.find(event->eventTypeId);
663 if (iter != eventHandlers.end()) {
664 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
665 return iter->second(inputEvent);
666 }
667 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
668 }
669
OH_ArkUI_UIInputEvent_GetPressedKeys(const ArkUI_UIInputEvent * event,int32_t * pressedKeyCodes,int32_t * length)670 int32_t OH_ArkUI_UIInputEvent_GetPressedKeys(
671 const ArkUI_UIInputEvent* event, int32_t* pressedKeyCodes, int32_t* length)
672 {
673 CheckSupportedScenarioAndResetEventStatus(
674 S_NODE_ON_KEY_EVENT | S_NODE_ON_KEY_PRE_IME | S_NODE_DISPATCH_KEY_EVENT, event);
675 if (!event || !pressedKeyCodes || !length) {
676 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
677 }
678 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
679 if (!keyEvent) {
680 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
681 }
682 auto inputLength = *length;
683 if (keyEvent->keyCodesLength > inputLength) {
684 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH);
685 }
686 *length = keyEvent->keyCodesLength;
687 for (int i = 0; i < keyEvent->keyCodesLength; i++) {
688 pressedKeyCodes[i] = keyEvent->pressedKeyCodes[i];
689 }
690
691 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
692 }
693
OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent * event)694 uint32_t OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent* event)
695 {
696 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
697 S_NODE_ON_HOVER_MOVE | S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT |
698 S_GESTURE_TOUCH_EVENT,
699 event);
700 if (!event) {
701 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
702 }
703 switch (event->eventTypeId) {
704 case C_TOUCH_EVENT_ID: {
705 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
706 if (!touchEvent) {
707 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
708 }
709 if (touchEvent->subKind == ON_HOVER_MOVE) {
710 RETURN_RET_WITH_STATUS_CHECK(1, ARKUI_ERROR_CODE_NO_ERROR);
711 }
712 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointSize, ARKUI_ERROR_CODE_NO_ERROR);
713 }
714 case C_MOUSE_EVENT_ID: {
715 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
716 if (!mouseEvent) {
717 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
718 }
719 RETURN_RET_WITH_STATUS_CHECK(1, ARKUI_ERROR_CODE_NO_ERROR);
720 }
721 case C_AXIS_EVENT_ID: {
722 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
723 if (!axisEvent) {
724 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
725 }
726 RETURN_RET_WITH_STATUS_CHECK(1, ARKUI_ERROR_CODE_NO_ERROR);
727 }
728 case C_CLICK_EVENT_ID: {
729 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
730 if (!clickEvent) {
731 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
732 }
733 RETURN_RET_WITH_STATUS_CHECK(clickEvent->clickPointSize, ARKUI_ERROR_CODE_NO_ERROR);
734 }
735 default:
736 break;
737 }
738 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_NO_ERROR);
739 }
740
OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)741 int32_t OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
742 {
743 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
744 S_NODE_ON_HOVER_MOVE | S_NODE_ON_AXIS | S_GESTURE_TOUCH_EVENT |
745 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
746 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
747 if (!event) {
748 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
749 }
750 switch (event->eventTypeId) {
751 case C_TOUCH_EVENT_ID: {
752 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
753 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
754 if (pointerIndex != 0) {
755 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
756 }
757 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.id, ARKUI_ERROR_CODE_NO_ERROR);
758 }
759 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
760 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
761 }
762 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].id, ARKUI_ERROR_CODE_NO_ERROR);
763 }
764 case C_MOUSE_EVENT_ID: {
765 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
766 if (!mouseEvent || pointerIndex != 0) {
767 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
768 }
769 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.id, ARKUI_ERROR_CODE_NO_ERROR);
770 }
771 case C_AXIS_EVENT_ID: {
772 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
773 if (!axisEvent || pointerIndex != 0) {
774 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
775 }
776 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.id, ARKUI_ERROR_CODE_NO_ERROR);
777 }
778 default:
779 break;
780 }
781 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
782 }
783
HandleCClickEventX(const ArkUI_UIInputEvent * event)784 float HandleCClickEventX(const ArkUI_UIInputEvent* event)
785 {
786 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
787 if (!clickEvent) {
788 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
789 }
790 RETURN_RET_WITH_STATUS_CHECK(clickEvent->localX, ARKUI_ERROR_CODE_NO_ERROR);
791 }
792
HandleCTouchEventX(const ArkUI_UIInputEvent * event)793 float HandleCTouchEventX(const ArkUI_UIInputEvent* event)
794 {
795 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
796 if (!touchEvent) {
797 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
798 }
799 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
800 }
801
HandleCMouseEventX(const ArkUI_UIInputEvent * event)802 float HandleCMouseEventX(const ArkUI_UIInputEvent* event)
803 {
804 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
805 if (!mouseEvent) {
806 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
807 }
808 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
809 }
810
HandleCAxisEventX(const ArkUI_UIInputEvent * event)811 float HandleCAxisEventX(const ArkUI_UIInputEvent* event)
812 {
813 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
814 if (!axisEvent) {
815 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
816 }
817 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
818 }
819
HandleTouchEventX(const ArkUI_UIInputEvent * event)820 float HandleTouchEventX(const ArkUI_UIInputEvent* event)
821 {
822 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
823 if (touchEvent) {
824 RETURN_RET_WITH_STATUS_CHECK(touchEvent->localX, ARKUI_ERROR_CODE_NO_ERROR);
825 }
826 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
827 }
828
HandleAxisEventX(const ArkUI_UIInputEvent * event)829 float HandleAxisEventX(const ArkUI_UIInputEvent* event)
830 {
831 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
832 if (axisEvent) {
833 RETURN_RET_WITH_STATUS_CHECK(axisEvent->localX, ARKUI_ERROR_CODE_NO_ERROR);
834 }
835 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
836 }
837
OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent * event)838 float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)
839 {
840 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
841 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
842 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
843 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
844 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
845 if (!event) {
846 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
847 }
848 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
849 { C_TOUCH_EVENT_ID, HandleCTouchEventX },
850 { TOUCH_EVENT_ID, HandleTouchEventX },
851 { AXIS_EVENT_ID, HandleAxisEventX },
852 { C_MOUSE_EVENT_ID, HandleCMouseEventX },
853 { C_AXIS_EVENT_ID, HandleCAxisEventX },
854 { C_CLICK_EVENT_ID, HandleCClickEventX },
855 };
856 auto it = eventHandlers.find(event->eventTypeId);
857 if (it != eventHandlers.end()) {
858 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
859 return it->second(inputEvent);
860 }
861 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
862 }
863
OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)864 float OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
865 {
866 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
867 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
868 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
869 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
870 if (!event) {
871 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
872 }
873 switch (event->eventTypeId) {
874 case C_TOUCH_EVENT_ID: {
875 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
876 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
877 if (pointerIndex != 0) {
878 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
879 }
880 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
881 }
882 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
883 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
884 }
885 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].nodeX, ARKUI_ERROR_CODE_NO_ERROR);
886 }
887 case C_MOUSE_EVENT_ID: {
888 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
889 if (!mouseEvent || pointerIndex != 0) {
890 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
891 }
892 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
893 }
894 case C_AXIS_EVENT_ID: {
895 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
896 if (!axisEvent || pointerIndex != 0) {
897 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
898 }
899 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.nodeX, ARKUI_ERROR_CODE_NO_ERROR);
900 }
901 default:
902 break;
903 }
904 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
905 }
906
HandleCClickEventY(const ArkUI_UIInputEvent * event)907 float HandleCClickEventY(const ArkUI_UIInputEvent* event)
908 {
909 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
910 if (!clickEvent) {
911 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
912 }
913 RETURN_RET_WITH_STATUS_CHECK(clickEvent->localY, ARKUI_ERROR_CODE_NO_ERROR);
914 }
915
HandleCTouchEventY(const ArkUI_UIInputEvent * event)916 float HandleCTouchEventY(const ArkUI_UIInputEvent* event)
917 {
918 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
919 if (!touchEvent) {
920 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
921 }
922 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
923 }
924
HandleCMouseEventY(const ArkUI_UIInputEvent * event)925 float HandleCMouseEventY(const ArkUI_UIInputEvent* event)
926 {
927 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
928 if (!mouseEvent) {
929 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
930 }
931 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
932 }
933
HandleCAxisEventY(const ArkUI_UIInputEvent * event)934 float HandleCAxisEventY(const ArkUI_UIInputEvent* event)
935 {
936 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
937 if (!axisEvent) {
938 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
939 }
940 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
941 }
942
HandleTouchEventY(const ArkUI_UIInputEvent * event)943 float HandleTouchEventY(const ArkUI_UIInputEvent* event)
944 {
945 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
946 if (touchEvent) {
947 RETURN_RET_WITH_STATUS_CHECK(touchEvent->localY, ARKUI_ERROR_CODE_NO_ERROR);
948 }
949 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
950 }
951
HandleAxisEventY(const ArkUI_UIInputEvent * event)952 float HandleAxisEventY(const ArkUI_UIInputEvent* event)
953 {
954 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
955 if (axisEvent) {
956 RETURN_RET_WITH_STATUS_CHECK(axisEvent->localY, ARKUI_ERROR_CODE_NO_ERROR);
957 }
958 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
959 }
960
OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent * event)961 float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)
962 {
963 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
964 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
965 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
966 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
967 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
968 if (!event) {
969 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
970 }
971 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
972 { C_TOUCH_EVENT_ID, HandleCTouchEventY },
973 { TOUCH_EVENT_ID, HandleTouchEventY },
974 { AXIS_EVENT_ID, HandleAxisEventY },
975 { C_MOUSE_EVENT_ID, HandleCMouseEventY },
976 { C_AXIS_EVENT_ID, HandleCAxisEventY },
977 { C_CLICK_EVENT_ID, HandleCClickEventY },
978 };
979 auto it = eventHandlers.find(event->eventTypeId);
980 if (it != eventHandlers.end()) {
981 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
982 return it->second(inputEvent);
983 }
984 LOGE("The parameter of OH_ArkUI_PointerEvent_GetY is invalid");
985 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
986 }
987
OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)988 float OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
989 {
990 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
991 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
992 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
993 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
994 if (!event) {
995 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
996 }
997 switch (event->eventTypeId) {
998 case C_TOUCH_EVENT_ID: {
999 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1000 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1001 if (pointerIndex != 0) {
1002 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1003 }
1004 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
1005 }
1006 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1007 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1008 }
1009 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].nodeY, ARKUI_ERROR_CODE_NO_ERROR);
1010 }
1011 case C_MOUSE_EVENT_ID: {
1012 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1013 if (!mouseEvent || pointerIndex != 0) {
1014 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1015 }
1016 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
1017 }
1018 case C_AXIS_EVENT_ID: {
1019 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1020 if (!axisEvent || pointerIndex != 0) {
1021 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1022 }
1023 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.nodeY, ARKUI_ERROR_CODE_NO_ERROR);
1024 }
1025 default:
1026 break;
1027 }
1028 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1029 }
1030
HandleCTouchEventWindowX(const ArkUI_UIInputEvent * event)1031 float HandleCTouchEventWindowX(const ArkUI_UIInputEvent* event)
1032 {
1033 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1034 if (!touchEvent) {
1035 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1036 }
1037 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1038 }
1039
HandleTouchEventWindowX(const ArkUI_UIInputEvent * event)1040 float HandleTouchEventWindowX(const ArkUI_UIInputEvent* event)
1041 {
1042 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1043 if (touchEvent) {
1044 RETURN_RET_WITH_STATUS_CHECK(touchEvent->x, ARKUI_ERROR_CODE_NO_ERROR);
1045 }
1046 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1047 }
1048
HandleAxisEventWindowX(const ArkUI_UIInputEvent * event)1049 float HandleAxisEventWindowX(const ArkUI_UIInputEvent* event)
1050 {
1051 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1052 if (axisEvent) {
1053 RETURN_RET_WITH_STATUS_CHECK(axisEvent->x, ARKUI_ERROR_CODE_NO_ERROR);
1054 }
1055 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1056 }
1057
HandleCMouseEventWindowX(const ArkUI_UIInputEvent * event)1058 float HandleCMouseEventWindowX(const ArkUI_UIInputEvent* event)
1059 {
1060 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1061 if (!mouseEvent) {
1062 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1063 }
1064 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1065 }
1066
HandleCAxisEventWindowX(const ArkUI_UIInputEvent * event)1067 float HandleCAxisEventWindowX(const ArkUI_UIInputEvent* event)
1068 {
1069 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1070 if (!axisEvent) {
1071 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1072 }
1073 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1074 }
1075
HandleCClickEventWindowX(const ArkUI_UIInputEvent * event)1076 float HandleCClickEventWindowX(const ArkUI_UIInputEvent* event)
1077 {
1078 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1079 if (!clickEvent) {
1080 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1081 }
1082 RETURN_RET_WITH_STATUS_CHECK(clickEvent->windowX, ARKUI_ERROR_CODE_NO_ERROR);
1083 }
1084
OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent * event)1085 float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
1086 {
1087 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1088 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1089 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1090 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
1091 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1092 if (!event) {
1093 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1094 }
1095 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1096 { C_TOUCH_EVENT_ID, HandleCTouchEventWindowX },
1097 { TOUCH_EVENT_ID, HandleTouchEventWindowX },
1098 { AXIS_EVENT_ID, HandleAxisEventWindowX },
1099 { C_MOUSE_EVENT_ID, HandleCMouseEventWindowX },
1100 { C_AXIS_EVENT_ID, HandleCAxisEventWindowX },
1101 { C_CLICK_EVENT_ID, HandleCClickEventWindowX },
1102 };
1103 auto it = eventHandlers.find(event->eventTypeId);
1104 if (it != eventHandlers.end()) {
1105 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1106 return it->second(inputEvent);
1107 }
1108 LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowX is invalid");
1109 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1110 }
1111
OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1112 float OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1113 {
1114 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1115 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1116 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1117 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1118 if (!event) {
1119 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1120 }
1121 switch (event->eventTypeId) {
1122 case C_TOUCH_EVENT_ID: {
1123 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1124 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1125 if (pointerIndex != 0) {
1126 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1127 }
1128 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1129 }
1130 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1131 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1132 }
1133 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].windowX, ARKUI_ERROR_CODE_NO_ERROR);
1134 }
1135 case C_MOUSE_EVENT_ID: {
1136 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1137 if (!mouseEvent || pointerIndex != 0) {
1138 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1139 }
1140 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1141 }
1142 case C_AXIS_EVENT_ID: {
1143 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1144 if (!axisEvent || pointerIndex != 0) {
1145 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1146 }
1147 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.windowX, ARKUI_ERROR_CODE_NO_ERROR);
1148 }
1149 default:
1150 break;
1151 }
1152 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1153 }
1154
HandleCClickEventWindowY(const ArkUI_UIInputEvent * event)1155 float HandleCClickEventWindowY(const ArkUI_UIInputEvent* event)
1156 {
1157 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1158 if (!clickEvent) {
1159 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1160 }
1161 RETURN_RET_WITH_STATUS_CHECK(clickEvent->windowY, ARKUI_ERROR_CODE_NO_ERROR);
1162 }
1163
HandleCTouchEventWindowY(const ArkUI_UIInputEvent * event)1164 float HandleCTouchEventWindowY(const ArkUI_UIInputEvent* event)
1165 {
1166 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1167 if (!touchEvent) {
1168 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1169 }
1170 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1171 }
1172
HandleCAxisEventWindowY(const ArkUI_UIInputEvent * event)1173 float HandleCAxisEventWindowY(const ArkUI_UIInputEvent* event)
1174 {
1175 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1176 if (!axisEvent) {
1177 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1178 }
1179 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1180 }
1181
HandleCMouseEventWindowY(const ArkUI_UIInputEvent * event)1182 float HandleCMouseEventWindowY(const ArkUI_UIInputEvent* event)
1183 {
1184 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1185 if (!mouseEvent) {
1186 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1187 }
1188 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1189 }
1190
HandleTouchEventWindowY(const ArkUI_UIInputEvent * event)1191 float HandleTouchEventWindowY(const ArkUI_UIInputEvent* event)
1192 {
1193 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1194 if (touchEvent) {
1195 RETURN_RET_WITH_STATUS_CHECK(touchEvent->y, ARKUI_ERROR_CODE_NO_ERROR);
1196 }
1197 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1198 }
1199
HandleAxisEventWindowY(const ArkUI_UIInputEvent * event)1200 float HandleAxisEventWindowY(const ArkUI_UIInputEvent* event)
1201 {
1202 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1203 if (axisEvent) {
1204 RETURN_RET_WITH_STATUS_CHECK(axisEvent->y, ARKUI_ERROR_CODE_NO_ERROR);
1205 }
1206 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1207 }
1208
OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent * event)1209 float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
1210 {
1211 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1212 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1213 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1214 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
1215 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1216 if (!event) {
1217 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1218 }
1219 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1220 { C_TOUCH_EVENT_ID, HandleCTouchEventWindowY },
1221 { TOUCH_EVENT_ID, HandleTouchEventWindowY },
1222 { AXIS_EVENT_ID, HandleAxisEventWindowY },
1223 { C_MOUSE_EVENT_ID, HandleCMouseEventWindowY },
1224 { C_AXIS_EVENT_ID, HandleCAxisEventWindowY },
1225 { C_CLICK_EVENT_ID, HandleCClickEventWindowY },
1226 };
1227 auto it = eventHandlers.find(event->eventTypeId);
1228 if (it != eventHandlers.end()) {
1229 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1230 return it->second(inputEvent);
1231 }
1232 LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowY is invalid");
1233 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1234 }
1235
OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1236 float OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1237 {
1238 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1239 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1240 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1241 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1242 if (!event) {
1243 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1244 }
1245 switch (event->eventTypeId) {
1246 case C_TOUCH_EVENT_ID: {
1247 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1248 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1249 if (pointerIndex != 0) {
1250 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1251 }
1252 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1253 }
1254 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1255 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1256 }
1257 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].windowY, ARKUI_ERROR_CODE_NO_ERROR);
1258 }
1259 case C_MOUSE_EVENT_ID: {
1260 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1261 if (!mouseEvent || pointerIndex != 0) {
1262 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1263 }
1264 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1265 }
1266 case C_AXIS_EVENT_ID: {
1267 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1268 if (!axisEvent || pointerIndex != 0) {
1269 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1270 }
1271 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.windowY, ARKUI_ERROR_CODE_NO_ERROR);
1272 }
1273 default:
1274 break;
1275 }
1276 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1277 }
1278
HandleCTouchEventDisplayX(const ArkUI_UIInputEvent * event)1279 float HandleCTouchEventDisplayX(const ArkUI_UIInputEvent* event)
1280 {
1281 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1282 if (!touchEvent) {
1283 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1284 }
1285 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1286 }
1287
HandleCClickEventDisplayX(const ArkUI_UIInputEvent * event)1288 float HandleCClickEventDisplayX(const ArkUI_UIInputEvent* event)
1289 {
1290 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1291 if (!clickEvent) {
1292 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1293 }
1294 RETURN_RET_WITH_STATUS_CHECK(clickEvent->displayX, ARKUI_ERROR_CODE_NO_ERROR);
1295 }
1296
HandleCMouseEventDisplayX(const ArkUI_UIInputEvent * event)1297 float HandleCMouseEventDisplayX(const ArkUI_UIInputEvent* event)
1298 {
1299 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1300 if (!mouseEvent) {
1301 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1302 }
1303 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1304 }
1305
HandleCAxisEventDisplayX(const ArkUI_UIInputEvent * event)1306 float HandleCAxisEventDisplayX(const ArkUI_UIInputEvent* event)
1307 {
1308 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1309 if (!axisEvent) {
1310 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1311 }
1312 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1313 }
1314
HandleTouchEventDisplayX(const ArkUI_UIInputEvent * event)1315 float HandleTouchEventDisplayX(const ArkUI_UIInputEvent* event)
1316 {
1317 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1318 if (touchEvent) {
1319 RETURN_RET_WITH_STATUS_CHECK(touchEvent->screenX, ARKUI_ERROR_CODE_NO_ERROR);
1320 }
1321 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1322 }
1323
HandleAxisEventDisplayX(const ArkUI_UIInputEvent * event)1324 float HandleAxisEventDisplayX(const ArkUI_UIInputEvent* event)
1325 {
1326 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1327 if (axisEvent) {
1328 RETURN_RET_WITH_STATUS_CHECK(axisEvent->screenX, ARKUI_ERROR_CODE_NO_ERROR);
1329 }
1330 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1331 }
1332
OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent * event)1333 float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
1334 {
1335 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1336 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1337 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1338 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
1339 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1340 if (!event) {
1341 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1342 }
1343 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1344 { C_TOUCH_EVENT_ID, HandleCTouchEventDisplayX },
1345 { TOUCH_EVENT_ID, HandleTouchEventDisplayX },
1346 { AXIS_EVENT_ID, HandleAxisEventDisplayX },
1347 { C_MOUSE_EVENT_ID, HandleCMouseEventDisplayX },
1348 { C_AXIS_EVENT_ID, HandleCAxisEventDisplayX },
1349 { C_CLICK_EVENT_ID, HandleCClickEventDisplayX },
1350 };
1351 auto it = eventHandlers.find(event->eventTypeId);
1352 if (it != eventHandlers.end()) {
1353 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1354 return it->second(inputEvent);
1355 }
1356 LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayX is invalid");
1357 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1358 }
1359
OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1360 float OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1361 {
1362 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1363 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1364 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1365 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1366 if (!event) {
1367 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1368 }
1369 switch (event->eventTypeId) {
1370 case C_TOUCH_EVENT_ID: {
1371 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1372 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1373 if (pointerIndex != 0) {
1374 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1375 }
1376 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1377 }
1378 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1379 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1380 }
1381 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].screenX, ARKUI_ERROR_CODE_NO_ERROR);
1382 }
1383 case C_MOUSE_EVENT_ID: {
1384 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1385 if (!mouseEvent || pointerIndex != 0) {
1386 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1387 }
1388 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1389 }
1390 case C_AXIS_EVENT_ID: {
1391 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1392 if (!axisEvent || pointerIndex != 0) {
1393 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1394 }
1395 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.screenX, ARKUI_ERROR_CODE_NO_ERROR);
1396 }
1397 default:
1398 break;
1399 }
1400 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1401 }
1402
HandleCTouchEventDisplayY(const ArkUI_UIInputEvent * event)1403 float HandleCTouchEventDisplayY(const ArkUI_UIInputEvent* event)
1404 {
1405 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1406 if (!touchEvent) {
1407 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1408 }
1409 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1410 }
1411
HandleCClickEventDisplayY(const ArkUI_UIInputEvent * event)1412 float HandleCClickEventDisplayY(const ArkUI_UIInputEvent* event)
1413 {
1414 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1415 if (!clickEvent) {
1416 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1417 }
1418 RETURN_RET_WITH_STATUS_CHECK(clickEvent->displayY, ARKUI_ERROR_CODE_NO_ERROR);
1419 }
1420
HandleCMouseEventDisplayY(const ArkUI_UIInputEvent * event)1421 float HandleCMouseEventDisplayY(const ArkUI_UIInputEvent* event)
1422 {
1423 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1424 if (!mouseEvent) {
1425 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1426 }
1427 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1428 }
1429
HandleCAxisEventDisplayY(const ArkUI_UIInputEvent * event)1430 float HandleCAxisEventDisplayY(const ArkUI_UIInputEvent* event)
1431 {
1432 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1433 if (!axisEvent) {
1434 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1435 }
1436 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1437 }
1438
HandleTouchEventDisplayY(const ArkUI_UIInputEvent * event)1439 float HandleTouchEventDisplayY(const ArkUI_UIInputEvent* event)
1440 {
1441 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1442 if (touchEvent) {
1443 RETURN_RET_WITH_STATUS_CHECK(touchEvent->screenY, ARKUI_ERROR_CODE_NO_ERROR);
1444 }
1445 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1446 }
1447
HandleAxisEventDisplayY(const ArkUI_UIInputEvent * event)1448 float HandleAxisEventDisplayY(const ArkUI_UIInputEvent* event)
1449 {
1450 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1451 if (axisEvent) {
1452 RETURN_RET_WITH_STATUS_CHECK(axisEvent->screenY, ARKUI_ERROR_CODE_NO_ERROR);
1453 }
1454 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1455 }
1456
OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent * event)1457 float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
1458 {
1459 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1460 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1461 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1462 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
1463 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1464 if (!event) {
1465 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1466 }
1467 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1468 { C_TOUCH_EVENT_ID, HandleCTouchEventDisplayY },
1469 { TOUCH_EVENT_ID, HandleTouchEventDisplayY },
1470 { AXIS_EVENT_ID, HandleAxisEventDisplayY },
1471 { C_MOUSE_EVENT_ID, HandleCMouseEventDisplayY },
1472 { C_AXIS_EVENT_ID, HandleCAxisEventDisplayY },
1473 { C_CLICK_EVENT_ID, HandleCClickEventDisplayY },
1474 };
1475 auto it = eventHandlers.find(event->eventTypeId);
1476 if (it != eventHandlers.end()) {
1477 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1478 return it->second(inputEvent);
1479 }
1480 LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayY is invalid");
1481 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1482 }
1483
OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1484 float OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1485 {
1486 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1487 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1488 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1489 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1490 if (!event) {
1491 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1492 }
1493 switch (event->eventTypeId) {
1494 case C_TOUCH_EVENT_ID: {
1495 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1496 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1497 if (pointerIndex != 0) {
1498 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1499 }
1500 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1501 }
1502 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1503 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1504 }
1505 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].screenY, ARKUI_ERROR_CODE_NO_ERROR);
1506 }
1507 case C_MOUSE_EVENT_ID: {
1508 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1509 if (!mouseEvent || pointerIndex != 0) {
1510 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1511 }
1512 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1513 }
1514 case C_AXIS_EVENT_ID: {
1515 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1516 if (!axisEvent || pointerIndex != 0) {
1517 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1518 }
1519 RETURN_RET_WITH_STATUS_CHECK(axisEvent->actionTouchPoint.screenY, ARKUI_ERROR_CODE_NO_ERROR);
1520 }
1521 default:
1522 break;
1523 }
1524 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1525 }
1526
HandleCTouchEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1527 float HandleCTouchEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1528 {
1529 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1530 if (!touchEvent) {
1531 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1532 }
1533 RETURN_RET_WITH_STATUS_CHECK(
1534 static_cast<float>(touchEvent->actionTouchPoint.globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1535 }
1536
HandleCClickEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1537 float HandleCClickEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1538 {
1539 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1540 if (!clickEvent) {
1541 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1542 }
1543 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(clickEvent->globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1544 }
1545
HandleCHoverEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1546 float HandleCHoverEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1547 {
1548 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
1549 if (!hoverEvent) {
1550 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1551 }
1552 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(hoverEvent->globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1553 }
1554
HandleCMouseEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1555 float HandleCMouseEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1556 {
1557 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1558 if (!mouseEvent) {
1559 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1560 }
1561 RETURN_RET_WITH_STATUS_CHECK(
1562 static_cast<float>(mouseEvent->actionTouchPoint.globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1563 }
1564
HandleCAxisEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1565 float HandleCAxisEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1566 {
1567 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1568 if (!axisEvent) {
1569 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1570 }
1571 RETURN_RET_WITH_STATUS_CHECK(
1572 static_cast<float>(axisEvent->actionTouchPoint.globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1573 }
1574
HandleTouchEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1575 float HandleTouchEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1576 {
1577 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1578 if (touchEvent) {
1579 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(touchEvent->globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1580 }
1581 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1582 }
1583
HandleAxisEventGlobalDisplayX(const ArkUI_UIInputEvent * event)1584 float HandleAxisEventGlobalDisplayX(const ArkUI_UIInputEvent* event)
1585 {
1586 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1587 if (axisEvent) {
1588 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(axisEvent->globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1589 }
1590 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1591 }
1592
OH_ArkUI_PointerEvent_GetGlobalDisplayX(const ArkUI_UIInputEvent * event)1593 float OH_ArkUI_PointerEvent_GetGlobalDisplayX(const ArkUI_UIInputEvent* event)
1594 {
1595 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1596 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1597 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1598 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT | S_NODE_ON_HOVER_EVENT;
1599 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1600 if (!event) {
1601 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1602 }
1603 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1604 { C_TOUCH_EVENT_ID, HandleCTouchEventGlobalDisplayX },
1605 { TOUCH_EVENT_ID, HandleTouchEventGlobalDisplayX },
1606 { AXIS_EVENT_ID, HandleAxisEventGlobalDisplayX },
1607 { C_MOUSE_EVENT_ID, HandleCMouseEventGlobalDisplayX },
1608 { C_AXIS_EVENT_ID, HandleCAxisEventGlobalDisplayX },
1609 { C_CLICK_EVENT_ID, HandleCClickEventGlobalDisplayX },
1610 { C_HOVER_EVENT_ID, HandleCHoverEventGlobalDisplayX },
1611 };
1612 auto it = eventHandlers.find(event->eventTypeId);
1613 if (it != eventHandlers.end()) {
1614 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1615 return it->second(inputEvent);
1616 }
1617 LOGE("The parameter of OH_ArkUI_PointerEvent_GetGlobalDisplayX is invalid");
1618 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1619 }
1620
OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1621 float OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1622 {
1623 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1624 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1625 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1626 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1627 if (!event) {
1628 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1629 }
1630 switch (event->eventTypeId) {
1631 case C_TOUCH_EVENT_ID: {
1632 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1633 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1634 if (pointerIndex != 0) {
1635 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1636 }
1637 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.globalDisplayX, ARKUI_ERROR_CODE_NO_ERROR);
1638 }
1639 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1640 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1641 }
1642 RETURN_RET_WITH_STATUS_CHECK(
1643 static_cast<float>(touchEvent->touchPointes[pointerIndex].globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1644 }
1645 case C_MOUSE_EVENT_ID: {
1646 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1647 if (!mouseEvent || pointerIndex != 0) {
1648 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1649 }
1650 RETURN_RET_WITH_STATUS_CHECK(
1651 static_cast<float>(mouseEvent->actionTouchPoint.globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1652 }
1653 case C_AXIS_EVENT_ID: {
1654 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1655 if (!axisEvent || pointerIndex != 0) {
1656 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1657 }
1658 RETURN_RET_WITH_STATUS_CHECK(
1659 static_cast<float>(axisEvent->actionTouchPoint.globalDisplayX), ARKUI_ERROR_CODE_NO_ERROR);
1660 }
1661 default:
1662 break;
1663 }
1664 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1665 }
1666
HandleCTouchEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1667 float HandleCTouchEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1668 {
1669 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1670 if (!touchEvent) {
1671 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1672 }
1673 RETURN_RET_WITH_STATUS_CHECK(
1674 static_cast<float>(touchEvent->actionTouchPoint.globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1675 }
1676
HandleCClickEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1677 float HandleCClickEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1678 {
1679 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1680 if (!clickEvent) {
1681 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1682 }
1683 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(clickEvent->globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1684 }
1685
HandleCHoverEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1686 float HandleCHoverEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1687 {
1688 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
1689 if (!hoverEvent) {
1690 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1691 }
1692 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(hoverEvent->globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1693 }
1694
HandleCMouseEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1695 float HandleCMouseEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1696 {
1697 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1698 if (!mouseEvent) {
1699 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1700 }
1701 RETURN_RET_WITH_STATUS_CHECK(
1702 static_cast<float>(mouseEvent->actionTouchPoint.globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1703 }
1704
HandleCAxisEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1705 float HandleCAxisEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1706 {
1707 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1708 if (!axisEvent) {
1709 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1710 }
1711 RETURN_RET_WITH_STATUS_CHECK(
1712 static_cast<float>(axisEvent->actionTouchPoint.globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1713 }
1714
HandleTouchEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1715 float HandleTouchEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1716 {
1717 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
1718 if (touchEvent) {
1719 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(touchEvent->globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1720 }
1721 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1722 }
1723
HandleAxisEventGlobalDisplayY(const ArkUI_UIInputEvent * event)1724 float HandleAxisEventGlobalDisplayY(const ArkUI_UIInputEvent* event)
1725 {
1726 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1727 if (axisEvent) {
1728 RETURN_RET_WITH_STATUS_CHECK(static_cast<float>(axisEvent->globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1729 }
1730 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1731 }
1732
OH_ArkUI_PointerEvent_GetGlobalDisplayY(const ArkUI_UIInputEvent * event)1733 float OH_ArkUI_PointerEvent_GetGlobalDisplayY(const ArkUI_UIInputEvent* event)
1734 {
1735 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1736 S_NODE_ON_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_MOVE |
1737 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
1738 S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT | S_NODE_ON_HOVER_EVENT;
1739 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1740 if (!event) {
1741 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1742 }
1743 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
1744 { C_TOUCH_EVENT_ID, HandleCTouchEventGlobalDisplayY },
1745 { TOUCH_EVENT_ID, HandleTouchEventGlobalDisplayY },
1746 { AXIS_EVENT_ID, HandleAxisEventGlobalDisplayY },
1747 { C_MOUSE_EVENT_ID, HandleCMouseEventGlobalDisplayY },
1748 { C_AXIS_EVENT_ID, HandleCAxisEventGlobalDisplayY },
1749 { C_CLICK_EVENT_ID, HandleCClickEventGlobalDisplayY },
1750 { C_HOVER_EVENT_ID, HandleCHoverEventGlobalDisplayY },
1751 };
1752 auto it = eventHandlers.find(event->eventTypeId);
1753 if (it != eventHandlers.end()) {
1754 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
1755 return it->second(inputEvent);
1756 }
1757 LOGE("The parameter of OH_ArkUI_PointerEvent_GetGlobalDisplayY is invalid");
1758 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1759 }
1760
OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1761 float OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1762 {
1763 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1764 S_NODE_ON_AXIS | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
1765 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT;
1766 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1767 if (!event) {
1768 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1769 }
1770 switch (event->eventTypeId) {
1771 case C_TOUCH_EVENT_ID: {
1772 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1773 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1774 if (pointerIndex != 0) {
1775 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1776 }
1777 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.globalDisplayY, ARKUI_ERROR_CODE_NO_ERROR);
1778 }
1779 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
1780 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1781 }
1782 RETURN_RET_WITH_STATUS_CHECK(
1783 static_cast<float>(touchEvent->touchPointes[pointerIndex].globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1784 }
1785 case C_MOUSE_EVENT_ID: {
1786 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1787 if (!mouseEvent || pointerIndex != 0) {
1788 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1789 }
1790 RETURN_RET_WITH_STATUS_CHECK(
1791 static_cast<float>(mouseEvent->actionTouchPoint.globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1792 }
1793 case C_AXIS_EVENT_ID: {
1794 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1795 if (!axisEvent || pointerIndex != 0) {
1796 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1797 }
1798 RETURN_RET_WITH_STATUS_CHECK(
1799 static_cast<float>(axisEvent->actionTouchPoint.globalDisplayY), ARKUI_ERROR_CODE_NO_ERROR);
1800 }
1801 default:
1802 break;
1803 }
1804 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1805 }
1806
OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1807 float OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1808 {
1809 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE |
1810 S_GESTURE_TOUCH_EVENT | S_GESTURE_MOUSE_EVENT, event);
1811 if (!event) {
1812 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1813 }
1814 switch (event->eventTypeId) {
1815 case C_TOUCH_EVENT_ID: {
1816 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1817 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1818 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_NO_ERROR);
1819 }
1820 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1821 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1822 }
1823 RETURN_RET_WITH_STATUS_CHECK(
1824 touchEvent->touchPointes[touchEvent->touchPointSize - 1].pressure, ARKUI_ERROR_CODE_NO_ERROR);
1825 }
1826 case C_MOUSE_EVENT_ID: {
1827 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1828 if (!mouseEvent) {
1829 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1830 }
1831 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->actionTouchPoint.pressure, ARKUI_ERROR_CODE_NO_ERROR);
1832 }
1833 case C_CLICK_EVENT_ID: {
1834 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1835 if (!clickEvent) {
1836 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1837 }
1838 RETURN_RET_WITH_STATUS_CHECK(clickEvent->pressure, ARKUI_ERROR_CODE_NO_ERROR);
1839 }
1840 default:
1841 break;
1842 }
1843 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1844 }
1845
OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1846 float OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1847 {
1848 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_CLICK_EVENT |
1849 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT;
1850 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1851 if (!event) {
1852 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1853 }
1854 switch (event->eventTypeId) {
1855 case C_TOUCH_EVENT_ID: {
1856 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1857 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1858 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.tiltX, ARKUI_ERROR_CODE_NO_ERROR);
1859 }
1860 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1861 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1862 }
1863 RETURN_RET_WITH_STATUS_CHECK(
1864 touchEvent->touchPointes[touchEvent->touchPointSize - 1].tiltX, ARKUI_ERROR_CODE_NO_ERROR);
1865 }
1866 case C_CLICK_EVENT_ID: {
1867 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1868 if (!clickEvent) {
1869 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1870 }
1871 RETURN_RET_WITH_STATUS_CHECK(clickEvent->tiltX, ARKUI_ERROR_CODE_NO_ERROR);
1872 }
1873 case C_HOVER_EVENT_ID: {
1874 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
1875 if (!hoverEvent) {
1876 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1877 }
1878 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->tiltX, ARKUI_ERROR_CODE_NO_ERROR);
1879 }
1880 default:
1881 break;
1882 }
1883 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1884 }
1885
OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)1886 float OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
1887 {
1888 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_CLICK_EVENT |
1889 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT;
1890 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1891 if (!event) {
1892 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1893 }
1894 switch (event->eventTypeId) {
1895 case C_TOUCH_EVENT_ID: {
1896 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1897 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1898 RETURN_RET_WITH_STATUS_CHECK(touchEvent->actionTouchPoint.tiltY, ARKUI_ERROR_CODE_NO_ERROR);
1899 }
1900 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1901 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1902 }
1903 RETURN_RET_WITH_STATUS_CHECK(
1904 touchEvent->touchPointes[touchEvent->touchPointSize - 1].tiltY, ARKUI_ERROR_CODE_NO_ERROR);
1905 }
1906 case C_CLICK_EVENT_ID: {
1907 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1908 if (!clickEvent) {
1909 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1910 }
1911 RETURN_RET_WITH_STATUS_CHECK(clickEvent->tiltY, ARKUI_ERROR_CODE_NO_ERROR);
1912 }
1913 case C_HOVER_EVENT_ID: {
1914 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
1915 if (!hoverEvent) {
1916 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
1917 }
1918 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->tiltY, ARKUI_ERROR_CODE_NO_ERROR);
1919 }
1920 default:
1921 break;
1922 }
1923 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1924 }
1925
OH_ArkUI_PointerEvent_GetRollAngle(const ArkUI_UIInputEvent * event,double * rollAngle)1926 int32_t OH_ArkUI_PointerEvent_GetRollAngle(const ArkUI_UIInputEvent* event, double* rollAngle)
1927 {
1928 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_CLICK_EVENT |
1929 S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT;
1930 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
1931 if (rollAngle == nullptr || event == nullptr) {
1932 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
1933 }
1934 switch (event->eventTypeId) {
1935 case C_TOUCH_EVENT_ID: {
1936 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1937 if (touchEvent && touchEvent->subKind == ON_HOVER_MOVE) {
1938 *rollAngle = touchEvent->actionTouchPoint.rollAngle;
1939 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1940 }
1941 if (touchEvent && touchEvent->subKind == ON_TOUCH) {
1942 *rollAngle = touchEvent->rollAngle;
1943 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1944 }
1945 if (!touchEvent || touchEvent->touchPointSize <= 0) {
1946 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
1947 }
1948 *rollAngle = touchEvent->touchPointes[touchEvent->touchPointSize - 1].rollAngle;
1949 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1950 }
1951 case C_CLICK_EVENT_ID: {
1952 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
1953 if (!clickEvent) {
1954 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
1955 }
1956 *rollAngle = clickEvent->rollAngle;
1957 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1958 }
1959 case C_HOVER_EVENT_ID: {
1960 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
1961 if (!hoverEvent) {
1962 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
1963 }
1964 *rollAngle = hoverEvent->rollAngle;
1965 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1966 }
1967 default:
1968 break;
1969 }
1970 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1971 }
1972
OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent * event,ArkUI_InteractionHand * hand)1973 int32_t OH_ArkUI_PointerEvent_GetInteractionHand(const ArkUI_UIInputEvent *event, ArkUI_InteractionHand *hand)
1974 {
1975 CheckSupportedScenarioAndResetEventStatus(
1976 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_GESTURE_TOUCH_EVENT, event);
1977 if (!event || !hand) {
1978 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
1979 }
1980 switch (event->eventTypeId) {
1981 case C_TOUCH_EVENT_ID: {
1982 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1983 *hand = static_cast<ArkUI_InteractionHand>(touchEvent->actionTouchPoint.operatingHand);
1984 break;
1985 }
1986 default:
1987 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
1988 break;
1989 }
1990 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
1991 }
1992
OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent * event,int32_t pointerIndex,ArkUI_InteractionHand * hand)1993 int32_t OH_ArkUI_PointerEvent_GetInteractionHandByIndex(const ArkUI_UIInputEvent *event, int32_t pointerIndex,
1994 ArkUI_InteractionHand *hand)
1995 {
1996 CheckSupportedScenarioAndResetEventStatus(
1997 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_GESTURE_TOUCH_EVENT, event);
1998 if (!event || !hand) {
1999 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2000 }
2001
2002 switch (event->eventTypeId) {
2003 case C_TOUCH_EVENT_ID: {
2004 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2005 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
2006 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2007 }
2008 *hand = static_cast<ArkUI_InteractionHand>(touchEvent->touchPointes[pointerIndex].operatingHand);
2009 break;
2010 }
2011 default:
2012 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2013 break;
2014 }
2015 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2016 }
2017
OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)2018 float OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
2019 {
2020 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_HOVER_MOVE, event);
2021 if (!event) {
2022 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2023 }
2024 switch (event->eventTypeId) {
2025 case C_TOUCH_EVENT_ID: {
2026 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2027 if (!touchEvent || touchEvent->touchPointSize <= 0) {
2028 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2029 }
2030 RETURN_RET_WITH_STATUS_CHECK(
2031 touchEvent->touchPointes[touchEvent->touchPointSize - 1].contactAreaWidth, ARKUI_ERROR_CODE_NO_ERROR);
2032 }
2033 default:
2034 break;
2035 }
2036 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2037 }
2038
OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)2039 float OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
2040 {
2041 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_HOVER_MOVE, event);
2042 if (!event) {
2043 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2044 }
2045 switch (event->eventTypeId) {
2046 case C_TOUCH_EVENT_ID: {
2047 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2048 if (!touchEvent || touchEvent->touchPointSize <= 0) {
2049 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2050 }
2051 RETURN_RET_WITH_STATUS_CHECK(
2052 touchEvent->touchPointes[touchEvent->touchPointSize - 1].contactAreaHeight, ARKUI_ERROR_CODE_NO_ERROR);
2053 }
2054 default:
2055 break;
2056 }
2057 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2058 }
2059
OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent * event,uint32_t * pointerIndex)2060 int32_t OH_ArkUI_PointerEvent_GetChangedPointerId(const ArkUI_UIInputEvent* event, uint32_t* pointerIndex)
2061 {
2062 CheckSupportedScenarioAndResetEventStatus(
2063 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_GESTURE_TOUCH_EVENT, event);
2064 if (!event || !pointerIndex) {
2065 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2066 }
2067 switch (event->eventTypeId) {
2068 case C_TOUCH_EVENT_ID: {
2069 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2070 if (!touchEvent || touchEvent->touchPointSize <= 0) {
2071 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2072 }
2073 *pointerIndex = touchEvent->changedPointerId;
2074 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2075 }
2076 default:
2077 break;
2078 }
2079 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2080 }
2081
OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent * event)2082 uint32_t OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent* event)
2083 {
2084 CheckSupportedScenarioAndResetEventStatus(
2085 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2086 if (!event) {
2087 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2088 }
2089 switch (event->eventTypeId) {
2090 case C_TOUCH_EVENT_ID: {
2091 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2092 if (!touchEvent || !touchEvent->historyEvents) {
2093 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2094 }
2095 RETURN_RET_WITH_STATUS_CHECK(touchEvent->historySize, ARKUI_ERROR_CODE_NO_ERROR);
2096 }
2097 default:
2098 break;
2099 }
2100 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2101 }
2102
OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent * event,uint32_t historyIndex)2103 int64_t OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
2104 {
2105 CheckSupportedScenarioAndResetEventStatus(
2106 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2107 if (!event) {
2108 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2109 }
2110 switch (event->eventTypeId) {
2111 case C_TOUCH_EVENT_ID: {
2112 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2113 if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
2114 historyIndex < 0) {
2115 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2116 }
2117 RETURN_RET_WITH_STATUS_CHECK(touchEvent->historyEvents[historyIndex].timeStamp, ARKUI_ERROR_CODE_NO_ERROR);
2118 }
2119 default:
2120 break;
2121 }
2122 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2123 }
2124
OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent * event,uint32_t historyIndex)2125 uint32_t OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
2126 {
2127 CheckSupportedScenarioAndResetEventStatus(
2128 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2129 if (!event) {
2130 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2131 }
2132 switch (event->eventTypeId) {
2133 case C_TOUCH_EVENT_ID: {
2134 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2135 if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
2136 historyIndex < 0) {
2137 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2138 }
2139 RETURN_RET_WITH_STATUS_CHECK(
2140 touchEvent->historyEvents[historyIndex].touchPointSize, ARKUI_ERROR_CODE_NO_ERROR);
2141 }
2142 default:
2143 break;
2144 }
2145 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2146 }
2147
OH_ArkUI_PointerEvent_GetHistoryPointerId(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2148 int32_t OH_ArkUI_PointerEvent_GetHistoryPointerId(
2149 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2150 {
2151 CheckSupportedScenarioAndResetEventStatus(
2152 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2153 if (!event) {
2154 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2155 }
2156 switch (event->eventTypeId) {
2157 case C_TOUCH_EVENT_ID: {
2158 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2159 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2160 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2161 }
2162 RETURN_RET_WITH_STATUS_CHECK(
2163 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].id, ARKUI_ERROR_CODE_NO_ERROR);
2164 }
2165 default:
2166 break;
2167 }
2168 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2169 }
2170
OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2171 float OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2172 {
2173 CheckSupportedScenarioAndResetEventStatus(
2174 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2175 if (!event) {
2176 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2177 }
2178 switch (event->eventTypeId) {
2179 case C_TOUCH_EVENT_ID: {
2180 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2181 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2182 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2183 }
2184 RETURN_RET_WITH_STATUS_CHECK(
2185 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeX, ARKUI_ERROR_CODE_NO_ERROR);
2186 }
2187 default:
2188 break;
2189 }
2190 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2191 }
2192
OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2193 float OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2194 {
2195 CheckSupportedScenarioAndResetEventStatus(
2196 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2197 if (!event) {
2198 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2199 }
2200 switch (event->eventTypeId) {
2201 case C_TOUCH_EVENT_ID: {
2202 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2203 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2204 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2205 }
2206 RETURN_RET_WITH_STATUS_CHECK(
2207 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeY, ARKUI_ERROR_CODE_NO_ERROR);
2208 }
2209 default:
2210 break;
2211 }
2212 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2213 }
2214
OH_ArkUI_PointerEvent_GetHistoryWindowX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2215 float OH_ArkUI_PointerEvent_GetHistoryWindowX(
2216 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2217 {
2218 CheckSupportedScenarioAndResetEventStatus(
2219 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2220 if (!event) {
2221 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2222 }
2223 switch (event->eventTypeId) {
2224 case C_TOUCH_EVENT_ID: {
2225 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2226 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2227 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2228 }
2229 RETURN_RET_WITH_STATUS_CHECK(
2230 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowX, ARKUI_ERROR_CODE_NO_ERROR);
2231 }
2232 default:
2233 break;
2234 }
2235 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2236 }
2237
OH_ArkUI_PointerEvent_GetHistoryWindowY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2238 float OH_ArkUI_PointerEvent_GetHistoryWindowY(
2239 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2240 {
2241 CheckSupportedScenarioAndResetEventStatus(
2242 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2243 if (!event) {
2244 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2245 }
2246 switch (event->eventTypeId) {
2247 case C_TOUCH_EVENT_ID: {
2248 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2249 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2250 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2251 }
2252 RETURN_RET_WITH_STATUS_CHECK(
2253 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowY, ARKUI_ERROR_CODE_NO_ERROR);
2254 }
2255 default:
2256 break;
2257 }
2258 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2259 }
2260
OH_ArkUI_PointerEvent_GetHistoryDisplayX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2261 float OH_ArkUI_PointerEvent_GetHistoryDisplayX(
2262 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2263 {
2264 CheckSupportedScenarioAndResetEventStatus(
2265 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2266 if (!event) {
2267 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2268 }
2269 switch (event->eventTypeId) {
2270 case C_TOUCH_EVENT_ID: {
2271 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2272 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2273 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2274 }
2275 RETURN_RET_WITH_STATUS_CHECK(
2276 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenX, ARKUI_ERROR_CODE_NO_ERROR);
2277 }
2278 default:
2279 break;
2280 }
2281 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2282 }
2283
OH_ArkUI_PointerEvent_GetHistoryDisplayY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2284 float OH_ArkUI_PointerEvent_GetHistoryDisplayY(
2285 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2286 {
2287 CheckSupportedScenarioAndResetEventStatus(
2288 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2289 if (!event) {
2290 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2291 }
2292 switch (event->eventTypeId) {
2293 case C_TOUCH_EVENT_ID: {
2294 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2295 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2296 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2297 }
2298 RETURN_RET_WITH_STATUS_CHECK(
2299 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenY, ARKUI_ERROR_CODE_NO_ERROR);
2300 }
2301 default:
2302 break;
2303 }
2304 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2305 }
2306
OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2307 float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(
2308 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2309 {
2310 CheckSupportedScenarioAndResetEventStatus(
2311 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2312 if (!event) {
2313 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2314 }
2315 switch (event->eventTypeId) {
2316 case C_TOUCH_EVENT_ID: {
2317 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2318 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2319 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2320 }
2321 RETURN_RET_WITH_STATUS_CHECK(
2322 static_cast<float>(touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].globalDisplayX),
2323 ARKUI_ERROR_CODE_NO_ERROR);
2324 }
2325 default:
2326 break;
2327 }
2328 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2329 }
2330
OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2331 float OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(
2332 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2333 {
2334 CheckSupportedScenarioAndResetEventStatus(
2335 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2336 if (!event) {
2337 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2338 }
2339 switch (event->eventTypeId) {
2340 case C_TOUCH_EVENT_ID: {
2341 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2342 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2343 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2344 }
2345 RETURN_RET_WITH_STATUS_CHECK(
2346 static_cast<float>(touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].globalDisplayY),
2347 ARKUI_ERROR_CODE_NO_ERROR);
2348 }
2349 default:
2350 break;
2351 }
2352 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2353 }
2354
OH_ArkUI_PointerEvent_GetHistoryPressure(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2355 float OH_ArkUI_PointerEvent_GetHistoryPressure(
2356 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2357 {
2358 CheckSupportedScenarioAndResetEventStatus(
2359 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2360 if (!event) {
2361 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2362 }
2363 switch (event->eventTypeId) {
2364 case C_TOUCH_EVENT_ID: {
2365 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2366 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2367 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2368 }
2369 RETURN_RET_WITH_STATUS_CHECK(
2370 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].pressure, ARKUI_ERROR_CODE_NO_ERROR);
2371 }
2372 default:
2373 break;
2374 }
2375 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2376 }
2377
OH_ArkUI_PointerEvent_GetHistoryTiltX(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2378 float OH_ArkUI_PointerEvent_GetHistoryTiltX(
2379 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2380 {
2381 CheckSupportedScenarioAndResetEventStatus(
2382 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2383 if (!event) {
2384 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2385 }
2386 switch (event->eventTypeId) {
2387 case C_TOUCH_EVENT_ID: {
2388 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2389 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2390 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2391 }
2392 RETURN_RET_WITH_STATUS_CHECK(
2393 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltX, ARKUI_ERROR_CODE_NO_ERROR);
2394 }
2395 default:
2396 break;
2397 }
2398 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2399 }
2400
OH_ArkUI_PointerEvent_GetHistoryTiltY(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2401 float OH_ArkUI_PointerEvent_GetHistoryTiltY(
2402 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2403 {
2404 CheckSupportedScenarioAndResetEventStatus(
2405 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2406 if (!event) {
2407 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2408 }
2409 switch (event->eventTypeId) {
2410 case C_TOUCH_EVENT_ID: {
2411 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2412 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2413 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2414 }
2415 RETURN_RET_WITH_STATUS_CHECK(
2416 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltY, ARKUI_ERROR_CODE_NO_ERROR);
2417 }
2418 default:
2419 break;
2420 }
2421 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2422 }
2423
OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2424 float OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(
2425 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2426 {
2427 CheckSupportedScenarioAndResetEventStatus(
2428 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2429 if (!event) {
2430 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2431 }
2432 switch (event->eventTypeId) {
2433 case C_TOUCH_EVENT_ID: {
2434 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2435 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2436 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2437 }
2438 RETURN_RET_WITH_STATUS_CHECK(
2439 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaWidth,
2440 ARKUI_ERROR_CODE_NO_ERROR);
2441 }
2442 default:
2443 break;
2444 }
2445 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2446 }
2447
OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(const ArkUI_UIInputEvent * event,uint32_t pointerIndex,uint32_t historyIndex)2448 float OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(
2449 const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
2450 {
2451 CheckSupportedScenarioAndResetEventStatus(
2452 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_HOVER_MOVE, event);
2453 if (!event) {
2454 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2455 }
2456 switch (event->eventTypeId) {
2457 case C_TOUCH_EVENT_ID: {
2458 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2459 if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
2460 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2461 }
2462 RETURN_RET_WITH_STATUS_CHECK(
2463 touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaHeight,
2464 ARKUI_ERROR_CODE_NO_ERROR);
2465 }
2466 default:
2467 break;
2468 }
2469 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2470 }
2471
OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent * event)2472 double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
2473 {
2474 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_AXIS | S_GESTURE_AXIS_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
2475 if (!event) {
2476 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2477 }
2478 switch (event->eventTypeId) {
2479 case AXIS_EVENT_ID: {
2480 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
2481 if (!axisEvent) {
2482 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2483 }
2484 RETURN_RET_WITH_STATUS_CHECK(axisEvent->verticalAxis, ARKUI_ERROR_CODE_NO_ERROR);
2485 }
2486 case C_AXIS_EVENT_ID: {
2487 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
2488 if (!axisEvent) {
2489 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2490 }
2491 RETURN_RET_WITH_STATUS_CHECK(axisEvent->verticalAxis, ARKUI_ERROR_CODE_NO_ERROR);
2492 }
2493 default:
2494 break;
2495 }
2496 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2497 }
2498
OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent * event)2499 double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)
2500 {
2501 CheckSupportedScenarioAndResetEventStatus(S_GESTURE_AXIS_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
2502 if (!event) {
2503 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2504 }
2505 switch (event->eventTypeId) {
2506 case AXIS_EVENT_ID: {
2507 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
2508 if (!axisEvent) {
2509 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2510 }
2511 RETURN_RET_WITH_STATUS_CHECK(axisEvent->horizontalAxis, ARKUI_ERROR_CODE_NO_ERROR);
2512 }
2513 case C_AXIS_EVENT_ID: {
2514 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
2515 if (!axisEvent) {
2516 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2517 }
2518 RETURN_RET_WITH_STATUS_CHECK(axisEvent->horizontalAxis, ARKUI_ERROR_CODE_NO_ERROR);
2519 }
2520 default:
2521 break;
2522 }
2523 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2524 }
2525
OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent * event)2526 double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)
2527 {
2528 CheckSupportedScenarioAndResetEventStatus(S_GESTURE_AXIS_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
2529 if (!event) {
2530 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2531 }
2532 switch (event->eventTypeId) {
2533 case AXIS_EVENT_ID: {
2534 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
2535 if (!axisEvent) {
2536 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2537 }
2538 RETURN_RET_WITH_STATUS_CHECK(axisEvent->pinchAxisScale, ARKUI_ERROR_CODE_NO_ERROR);
2539 }
2540 case C_AXIS_EVENT_ID: {
2541 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
2542 if (!axisEvent) {
2543 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2544 }
2545 RETURN_RET_WITH_STATUS_CHECK(axisEvent->pinchAxisScale, ARKUI_ERROR_CODE_NO_ERROR);
2546 }
2547 default:
2548 break;
2549 }
2550 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2551 }
2552
OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent * event)2553 int32_t OH_ArkUI_AxisEvent_GetAxisAction(const ArkUI_UIInputEvent* event)
2554 {
2555 CheckSupportedScenarioAndResetEventStatus(S_GESTURE_AXIS_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
2556 if (!event) {
2557 RETURN_RET_WITH_STATUS_CHECK(UI_AXIS_EVENT_ACTION_NONE, ARKUI_ERROR_CODE_PARAM_INVALID);
2558 }
2559 switch (event->eventTypeId) {
2560 case AXIS_EVENT_ID: {
2561 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
2562 if (axisEvent) {
2563 RETURN_RET_WITH_STATUS_CHECK(
2564 OHOS::Ace::NodeModel::ConvertToCAxisActionType(static_cast<int32_t>(axisEvent->action)),
2565 ARKUI_ERROR_CODE_NO_ERROR);
2566 }
2567 break;
2568 }
2569 case C_AXIS_EVENT_ID: {
2570 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
2571 if (axisEvent) {
2572 RETURN_RET_WITH_STATUS_CHECK(
2573 OHOS::Ace::NodeModel::ConvertToCAxisActionType(axisEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
2574 }
2575 break;
2576 }
2577 default:
2578 RETURN_RET_WITH_STATUS_CHECK(UI_AXIS_EVENT_ACTION_NONE, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2579 }
2580 RETURN_RET_WITH_STATUS_CHECK(UI_AXIS_EVENT_ACTION_NONE, ARKUI_ERROR_CODE_PARAM_INVALID);
2581 }
2582
OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent * event,HitTestMode mode)2583 int32_t OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent* event, HitTestMode mode)
2584 {
2585 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_TOUCH_INTERCEPT, event);
2586 if (!event) {
2587 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2588 }
2589 switch (event->eventTypeId) {
2590 case C_TOUCH_EVENT_ID: {
2591 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2592 touchEvent->interceptResult = static_cast<int32_t>(mode);
2593 break;
2594 }
2595 case C_MOUSE_EVENT_ID: {
2596 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2597 if (!mouseEvent) {
2598 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2599 }
2600 RETURN_RET_WITH_STATUS_CHECK(
2601 mouseEvent->interceptResult = static_cast<int32_t>(mode), ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2602 }
2603 default:
2604 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2605 }
2606 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2607 }
2608
OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent * event,bool stopPropagation)2609 int32_t OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
2610 {
2611 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_HOVER_EVENT, event);
2612 if (!event) {
2613 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2614 }
2615 switch (event->eventTypeId) {
2616 case C_TOUCH_EVENT_ID: {
2617 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2618 touchEvent->stopPropagation = stopPropagation;
2619 break;
2620 }
2621 case C_MOUSE_EVENT_ID: {
2622 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2623 mouseEvent->stopPropagation = stopPropagation;
2624 break;
2625 }
2626 case C_HOVER_EVENT_ID: {
2627 auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
2628 hoverEvent->stopPropagation = stopPropagation;
2629 break;
2630 }
2631 default:
2632 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2633 }
2634 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2635 }
2636
OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent * event)2637 int32_t OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent* event)
2638 {
2639 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_MOUSE, event);
2640 if (!event) {
2641 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
2642 }
2643 switch (event->eventTypeId) {
2644 case C_MOUSE_EVENT_ID: {
2645 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2646 if (!mouseEvent) {
2647 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
2648 }
2649 RETURN_RET_WITH_STATUS_CHECK(
2650 OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(mouseEvent->button), ARKUI_ERROR_CODE_NO_ERROR);
2651 }
2652 default:
2653 break;
2654 }
2655 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2656 }
2657
OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent * event)2658 int32_t OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent* event)
2659 {
2660 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_MOUSE | S_GESTURE_MOUSE_EVENT, event);
2661 if (!event) {
2662 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
2663 }
2664 switch (event->eventTypeId) {
2665 case C_MOUSE_EVENT_ID: {
2666 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2667 if (!mouseEvent) {
2668 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_CODE_PARAM_INVALID);
2669 }
2670 RETURN_RET_WITH_STATUS_CHECK(
2671 OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action), ARKUI_ERROR_CODE_NO_ERROR);
2672 }
2673 default:
2674 break;
2675 }
2676 RETURN_RET_WITH_STATUS_CHECK(-1, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2677 }
2678
OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent * event,uint32_t pointerIndex)2679 int64_t OH_ArkUI_PointerEvent_GetPressedTimeByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
2680 {
2681 CheckSupportedScenarioAndResetEventStatus(
2682 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_GESTURE_TOUCH_EVENT, event);
2683 if (!event) {
2684 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2685 }
2686 switch (event->eventTypeId) {
2687 case C_TOUCH_EVENT_ID: {
2688 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2689 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
2690 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2691 }
2692 RETURN_RET_WITH_STATUS_CHECK(touchEvent->touchPointes[pointerIndex].pressedTime, ARKUI_ERROR_CODE_NO_ERROR);
2693 }
2694 default:
2695 break;
2696 }
2697 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2698 }
2699
OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent * event)2700 float OH_ArkUI_MouseEvent_GetRawDeltaX(const ArkUI_UIInputEvent* event)
2701 {
2702 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_MOUSE, event);
2703 if (!event) {
2704 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2705 }
2706 switch (event->eventTypeId) {
2707 case C_MOUSE_EVENT_ID: {
2708 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2709 if (!mouseEvent) {
2710 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2711 }
2712 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->rawDeltaX, ARKUI_ERROR_CODE_NO_ERROR);
2713 }
2714 default:
2715 break;
2716 }
2717 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2718 }
2719
OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent * event)2720 float OH_ArkUI_MouseEvent_GetRawDeltaY(const ArkUI_UIInputEvent* event)
2721 {
2722 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_MOUSE, event);
2723 if (!event) {
2724 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2725 }
2726 switch (event->eventTypeId) {
2727 case C_MOUSE_EVENT_ID: {
2728 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2729 if (!mouseEvent) {
2730 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2731 }
2732 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->rawDeltaY, ARKUI_ERROR_CODE_NO_ERROR);
2733 }
2734 default:
2735 break;
2736 }
2737 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2738 }
2739
OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent * event)2740 int32_t OH_ArkUI_UIInputEvent_GetTargetDisplayId(const ArkUI_UIInputEvent* event)
2741 {
2742 const int32_t supportedScenario =
2743 S_NODE_TOUCH_EVENT | S_NODE_ON_TOUCH_INTERCEPT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS | S_NODE_ON_AXIS |
2744 S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT |
2745 S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
2746 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
2747 if (!event) {
2748 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_CODE_PARAM_INVALID);
2749 }
2750 auto getTargetDisplayId = [](auto* specificEvent) -> int32_t {
2751 return specificEvent ? specificEvent->targetDisplayId : 0;
2752 };
2753 switch (event->eventTypeId) {
2754 case C_MOUSE_EVENT_ID:
2755 RETURN_RET_WITH_STATUS_CHECK(
2756 getTargetDisplayId(reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent)), ARKUI_ERROR_CODE_NO_ERROR);
2757 case C_TOUCH_EVENT_ID:
2758 RETURN_RET_WITH_STATUS_CHECK(
2759 getTargetDisplayId(reinterpret_cast<ArkUITouchEvent*>(event->inputEvent)), ARKUI_ERROR_CODE_NO_ERROR);
2760 case C_CLICK_EVENT_ID: {
2761 RETURN_RET_WITH_STATUS_CHECK(
2762 getTargetDisplayId(reinterpret_cast<ArkUIClickEvent*>(event->inputEvent)), ARKUI_ERROR_CODE_NO_ERROR);
2763 }
2764 case C_HOVER_EVENT_ID: {
2765 RETURN_RET_WITH_STATUS_CHECK(
2766 getTargetDisplayId(reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent)), ARKUI_ERROR_CODE_NO_ERROR);
2767 }
2768 case C_AXIS_EVENT_ID:
2769 RETURN_RET_WITH_STATUS_CHECK(
2770 getTargetDisplayId(reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent)), ARKUI_ERROR_CODE_NO_ERROR);
2771 case C_FOCUS_AXIS_EVENT_ID:
2772 RETURN_RET_WITH_STATUS_CHECK(getTargetDisplayId(reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent)),
2773 ARKUI_ERROR_CODE_NO_ERROR);
2774 case TOUCH_EVENT_ID: {
2775 RETURN_RET_WITH_STATUS_CHECK(
2776 getTargetDisplayId(reinterpret_cast<OHOS::Ace::TouchEvent*>(event->inputEvent)),
2777 ARKUI_ERROR_CODE_NO_ERROR);
2778 }
2779 case AXIS_EVENT_ID: {
2780 RETURN_RET_WITH_STATUS_CHECK(getTargetDisplayId(reinterpret_cast<OHOS::Ace::AxisEvent*>(event->inputEvent)),
2781 ARKUI_ERROR_CODE_NO_ERROR);
2782 }
2783 default:
2784 RETURN_RET_WITH_STATUS_CHECK(0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2785 }
2786 }
2787
OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent * event,int32_t * pressedButtons,int32_t * length)2788 int32_t OH_ArkUI_MouseEvent_GetPressedButtons(const ArkUI_UIInputEvent* event, int32_t* pressedButtons, int32_t* length)
2789 {
2790 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_MOUSE, event);
2791 if (!event || !pressedButtons || !length) {
2792 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2793 }
2794 switch (event->eventTypeId) {
2795 case C_MOUSE_EVENT_ID: {
2796 auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2797 if (!mouseEvent) {
2798 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2799 }
2800 auto inputLength = *length;
2801 if (mouseEvent->pressedButtonsLength > inputLength) {
2802 RETURN_RET_WITH_STATUS_CHECK(
2803 ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH);
2804 }
2805 *length = mouseEvent->pressedButtonsLength;
2806 for (int i = 0; i < mouseEvent->pressedButtonsLength; i++) {
2807 pressedButtons[i] = mouseEvent->pressedButtons[i];
2808 }
2809 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2810 }
2811 default:
2812 break;
2813 }
2814 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2815 }
2816
OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent * event,int32_t axis)2817 double OH_ArkUI_FocusAxisEvent_GetAxisValue(const ArkUI_UIInputEvent* event, int32_t axis)
2818 {
2819 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_FOCUS_AXIS, event);
2820 if (!event) {
2821 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2822 }
2823 if (event->eventTypeId != C_FOCUS_AXIS_EVENT_ID) {
2824 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2825 }
2826 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
2827 if (!focusAxisEvent) {
2828 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_CODE_PARAM_INVALID);
2829 }
2830 switch (axis) {
2831 case UI_FOCUS_AXIS_EVENT_ABS_X:
2832 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absXValue, ARKUI_ERROR_CODE_NO_ERROR);
2833 case UI_FOCUS_AXIS_EVENT_ABS_Y:
2834 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absYValue, ARKUI_ERROR_CODE_NO_ERROR);
2835 case UI_FOCUS_AXIS_EVENT_ABS_Z:
2836 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absZValue, ARKUI_ERROR_CODE_NO_ERROR);
2837 case UI_FOCUS_AXIS_EVENT_ABS_RZ:
2838 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absRzValue, ARKUI_ERROR_CODE_NO_ERROR);
2839 case UI_FOCUS_AXIS_EVENT_ABS_GAS:
2840 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absGasValue, ARKUI_ERROR_CODE_NO_ERROR);
2841 case UI_FOCUS_AXIS_EVENT_ABS_BRAKE:
2842 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absBrakeValue, ARKUI_ERROR_CODE_NO_ERROR);
2843 case UI_FOCUS_AXIS_EVENT_ABS_HAT0X:
2844 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absHat0XValue, ARKUI_ERROR_CODE_NO_ERROR);
2845 case UI_FOCUS_AXIS_EVENT_ABS_HAT0Y:
2846 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->absHat0YValue, ARKUI_ERROR_CODE_NO_ERROR);
2847 default:
2848 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2849 }
2850 RETURN_RET_WITH_STATUS_CHECK(0.0, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2851 }
2852
OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent * event,bool stopPropagation)2853 int32_t OH_ArkUI_FocusAxisEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
2854 {
2855 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_FOCUS_AXIS, event);
2856 if (!event) {
2857 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
2858 }
2859 switch (event->eventTypeId) {
2860 case C_FOCUS_AXIS_EVENT_ID: {
2861 auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
2862 focusAxisEvent->stopPropagation = stopPropagation;
2863 break;
2864 }
2865 default:
2866 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2867 }
2868 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
2869 }
2870
HandleCMouseEventTargetWidth(const ArkUI_UIInputEvent * event)2871 float HandleCMouseEventTargetWidth(const ArkUI_UIInputEvent* event)
2872 {
2873 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2874 if (!mouseEvent) {
2875 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2876 }
2877 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2878 }
2879
HandleCTouchEventTargetWidth(const ArkUI_UIInputEvent * event)2880 float HandleCTouchEventTargetWidth(const ArkUI_UIInputEvent* event)
2881 {
2882 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2883 if (!touchEvent) {
2884 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2885 }
2886 RETURN_RET_WITH_STATUS_CHECK(touchEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2887 }
2888
HandleCHoverEventTargetWidth(const ArkUI_UIInputEvent * event)2889 float HandleCHoverEventTargetWidth(const ArkUI_UIInputEvent* event)
2890 {
2891 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
2892 if (!hoverEvent) {
2893 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2894 }
2895 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2896 }
2897
HandleCClickEventTargetWidth(const ArkUI_UIInputEvent * event)2898 float HandleCClickEventTargetWidth(const ArkUI_UIInputEvent* event)
2899 {
2900 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
2901 if (!clickEvent) {
2902 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2903 }
2904 RETURN_RET_WITH_STATUS_CHECK(clickEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2905 }
2906
HandleCAxisEventTargetWidth(const ArkUI_UIInputEvent * event)2907 float HandleCAxisEventTargetWidth(const ArkUI_UIInputEvent* event)
2908 {
2909 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
2910 if (!axisEvent) {
2911 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2912 }
2913 RETURN_RET_WITH_STATUS_CHECK(axisEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2914 }
2915
HandleCFocusAxisEventTargetWidth(const ArkUI_UIInputEvent * event)2916 float HandleCFocusAxisEventTargetWidth(const ArkUI_UIInputEvent* event)
2917 {
2918 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
2919 if (!focusAxisEvent) {
2920 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2921 }
2922 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2923 }
2924
HandleAxisEventTargetWidth(const ArkUI_UIInputEvent * event)2925 float HandleAxisEventTargetWidth(const ArkUI_UIInputEvent* event)
2926 {
2927 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
2928 if (!axisEvent) {
2929 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2930 }
2931 RETURN_RET_WITH_STATUS_CHECK(axisEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2932 }
2933
HandleTouchEventTargetWidth(const ArkUI_UIInputEvent * event)2934 float HandleTouchEventTargetWidth(const ArkUI_UIInputEvent* event)
2935 {
2936 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
2937 if (!touchEvent) {
2938 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2939 }
2940 RETURN_RET_WITH_STATUS_CHECK(touchEvent->width, ARKUI_ERROR_CODE_NO_ERROR);
2941 }
2942
OH_ArkUI_UIInputEvent_GetEventTargetWidth(const ArkUI_UIInputEvent * event)2943 float OH_ArkUI_UIInputEvent_GetEventTargetWidth(const ArkUI_UIInputEvent* event)
2944 {
2945 CheckSupportedScenarioAndResetEventStatus(
2946 S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT |
2947 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
2948 if (!event) {
2949 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2950 }
2951 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
2952 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetWidth },
2953 { TOUCH_EVENT_ID, HandleTouchEventTargetWidth },
2954 { AXIS_EVENT_ID, HandleAxisEventTargetWidth },
2955 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetWidth },
2956 { C_AXIS_EVENT_ID, HandleCAxisEventTargetWidth },
2957 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetWidth },
2958 { C_HOVER_EVENT_ID, HandleCHoverEventTargetWidth },
2959 { C_CLICK_EVENT_ID, HandleCClickEventTargetWidth },
2960 };
2961 auto it = eventHandlers.find(event->eventTypeId);
2962 if (it != eventHandlers.end()) {
2963 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
2964 return it->second(inputEvent);
2965 }
2966 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
2967 }
2968
HandleCMouseEventTargetHeight(const ArkUI_UIInputEvent * event)2969 float HandleCMouseEventTargetHeight(const ArkUI_UIInputEvent* event)
2970 {
2971 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
2972 if (!mouseEvent) {
2973 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2974 }
2975 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
2976 }
2977
HandleCTouchEventTargetHeight(const ArkUI_UIInputEvent * event)2978 float HandleCTouchEventTargetHeight(const ArkUI_UIInputEvent* event)
2979 {
2980 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
2981 if (!touchEvent) {
2982 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2983 }
2984 RETURN_RET_WITH_STATUS_CHECK(touchEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
2985 }
2986
HandleCHoverEventTargetHeight(const ArkUI_UIInputEvent * event)2987 float HandleCHoverEventTargetHeight(const ArkUI_UIInputEvent* event)
2988 {
2989 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
2990 if (!hoverEvent) {
2991 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
2992 }
2993 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
2994 }
2995
HandleCClickEventTargetHeight(const ArkUI_UIInputEvent * event)2996 float HandleCClickEventTargetHeight(const ArkUI_UIInputEvent* event)
2997 {
2998 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
2999 if (!clickEvent) {
3000 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3001 }
3002 RETURN_RET_WITH_STATUS_CHECK(clickEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
3003 }
3004
HandleCAxisEventTargetHeight(const ArkUI_UIInputEvent * event)3005 float HandleCAxisEventTargetHeight(const ArkUI_UIInputEvent* event)
3006 {
3007 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3008 if (!axisEvent) {
3009 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3010 }
3011 RETURN_RET_WITH_STATUS_CHECK(axisEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
3012 }
3013
HandleCFocusAxisEventTargetHeight(const ArkUI_UIInputEvent * event)3014 float HandleCFocusAxisEventTargetHeight(const ArkUI_UIInputEvent* event)
3015 {
3016 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3017 if (!focusAxisEvent) {
3018 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3019 }
3020 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
3021 }
3022
HandleAxisEventTargetHeight(const ArkUI_UIInputEvent * event)3023 float HandleAxisEventTargetHeight(const ArkUI_UIInputEvent* event)
3024 {
3025 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3026 if (!axisEvent) {
3027 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3028 }
3029 RETURN_RET_WITH_STATUS_CHECK(axisEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
3030 }
3031
HandleTouchEventTargetHeight(const ArkUI_UIInputEvent * event)3032 float HandleTouchEventTargetHeight(const ArkUI_UIInputEvent* event)
3033 {
3034 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3035 if (!touchEvent) {
3036 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3037 }
3038 RETURN_RET_WITH_STATUS_CHECK(touchEvent->height, ARKUI_ERROR_CODE_NO_ERROR);
3039 }
3040
OH_ArkUI_UIInputEvent_GetEventTargetHeight(const ArkUI_UIInputEvent * event)3041 float OH_ArkUI_UIInputEvent_GetEventTargetHeight(const ArkUI_UIInputEvent* event)
3042 {
3043 CheckSupportedScenarioAndResetEventStatus(
3044 S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT |
3045 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
3046 if (!event) {
3047 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3048 }
3049 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
3050 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetHeight },
3051 { TOUCH_EVENT_ID, HandleTouchEventTargetHeight },
3052 { AXIS_EVENT_ID, HandleAxisEventTargetHeight },
3053 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetHeight },
3054 { C_AXIS_EVENT_ID, HandleCAxisEventTargetHeight },
3055 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetHeight },
3056 { C_HOVER_EVENT_ID, HandleCHoverEventTargetHeight },
3057 { C_CLICK_EVENT_ID, HandleCClickEventTargetHeight },
3058 };
3059 auto it = eventHandlers.find(event->eventTypeId);
3060 if (it != eventHandlers.end()) {
3061 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3062 return it->second(inputEvent);
3063 }
3064 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3065 }
3066
HandleCMouseEventTargetPositionX(const ArkUI_UIInputEvent * event)3067 float HandleCMouseEventTargetPositionX(const ArkUI_UIInputEvent* event)
3068 {
3069 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
3070 if (!mouseEvent) {
3071 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3072 }
3073 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3074 }
3075
HandleCTouchEventTargetPositionX(const ArkUI_UIInputEvent * event)3076 float HandleCTouchEventTargetPositionX(const ArkUI_UIInputEvent* event)
3077 {
3078 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3079 if (!touchEvent) {
3080 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3081 }
3082 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3083 }
3084
HandleCHoverEventTargetPositionX(const ArkUI_UIInputEvent * event)3085 float HandleCHoverEventTargetPositionX(const ArkUI_UIInputEvent* event)
3086 {
3087 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3088 if (!hoverEvent) {
3089 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3090 }
3091 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3092 }
3093
HandleCClickEventTargetPositionX(const ArkUI_UIInputEvent * event)3094 float HandleCClickEventTargetPositionX(const ArkUI_UIInputEvent* event)
3095 {
3096 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
3097 if (!clickEvent) {
3098 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3099 }
3100 RETURN_RET_WITH_STATUS_CHECK(clickEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3101 }
3102
HandleCAxisEventTargetPositionX(const ArkUI_UIInputEvent * event)3103 float HandleCAxisEventTargetPositionX(const ArkUI_UIInputEvent* event)
3104 {
3105 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3106 if (!axisEvent) {
3107 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3108 }
3109 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3110 }
3111
HandleCFocusAxisEventTargetPositionX(const ArkUI_UIInputEvent * event)3112 float HandleCFocusAxisEventTargetPositionX(const ArkUI_UIInputEvent* event)
3113 {
3114 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3115 if (!focusAxisEvent) {
3116 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3117 }
3118 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3119 }
3120
HandleAxisEventTargetPositionX(const ArkUI_UIInputEvent * event)3121 float HandleAxisEventTargetPositionX(const ArkUI_UIInputEvent* event)
3122 {
3123 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3124 if (!axisEvent) {
3125 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3126 }
3127 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3128 }
3129
HandleTouchEventTargetPositionX(const ArkUI_UIInputEvent * event)3130 float HandleTouchEventTargetPositionX(const ArkUI_UIInputEvent* event)
3131 {
3132 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3133 if (!touchEvent) {
3134 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3135 }
3136 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3137 }
3138
OH_ArkUI_UIInputEvent_GetEventTargetPositionX(const ArkUI_UIInputEvent * event)3139 float OH_ArkUI_UIInputEvent_GetEventTargetPositionX(const ArkUI_UIInputEvent* event)
3140 {
3141 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS |
3142 S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE |
3143 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
3144 S_NXC_DISPATCH_AXIS_EVENT,
3145 event);
3146 if (!event) {
3147 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3148 }
3149 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
3150 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetPositionX },
3151 { TOUCH_EVENT_ID, HandleTouchEventTargetPositionX },
3152 { AXIS_EVENT_ID, HandleAxisEventTargetPositionX },
3153 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetPositionX },
3154 { C_AXIS_EVENT_ID, HandleCAxisEventTargetPositionX },
3155 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetPositionX },
3156 { C_HOVER_EVENT_ID, HandleCHoverEventTargetPositionX },
3157 { C_CLICK_EVENT_ID, HandleCClickEventTargetPositionX },
3158 };
3159 auto it = eventHandlers.find(event->eventTypeId);
3160 if (it != eventHandlers.end()) {
3161 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3162 return it->second(inputEvent);
3163 }
3164 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3165 }
3166
HandleCMouseEventTargetPositionY(const ArkUI_UIInputEvent * event)3167 float HandleCMouseEventTargetPositionY(const ArkUI_UIInputEvent* event)
3168 {
3169 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
3170 if (!mouseEvent) {
3171 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3172 }
3173 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3174 }
3175
HandleCTouchEventTargetPositionY(const ArkUI_UIInputEvent * event)3176 float HandleCTouchEventTargetPositionY(const ArkUI_UIInputEvent* event)
3177 {
3178 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3179 if (!touchEvent) {
3180 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3181 }
3182 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3183 }
3184
HandleCHoverEventTargetPositionY(const ArkUI_UIInputEvent * event)3185 float HandleCHoverEventTargetPositionY(const ArkUI_UIInputEvent* event)
3186 {
3187 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3188 if (!hoverEvent) {
3189 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3190 }
3191 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3192 }
3193
HandleCClickEventTargetPositionY(const ArkUI_UIInputEvent * event)3194 float HandleCClickEventTargetPositionY(const ArkUI_UIInputEvent* event)
3195 {
3196 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
3197 if (!clickEvent) {
3198 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3199 }
3200 RETURN_RET_WITH_STATUS_CHECK(clickEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3201 }
3202
HandleCAxisEventTargetPositionY(const ArkUI_UIInputEvent * event)3203 float HandleCAxisEventTargetPositionY(const ArkUI_UIInputEvent* event)
3204 {
3205 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3206 if (!axisEvent) {
3207 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3208 }
3209 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3210 }
3211
HandleCFocusAxisEventTargetPositionY(const ArkUI_UIInputEvent * event)3212 float HandleCFocusAxisEventTargetPositionY(const ArkUI_UIInputEvent* event)
3213 {
3214 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3215 if (!focusAxisEvent) {
3216 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3217 }
3218 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3219 }
3220
HandleAxisEventTargetPositionY(const ArkUI_UIInputEvent * event)3221 float HandleAxisEventTargetPositionY(const ArkUI_UIInputEvent* event)
3222 {
3223 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3224 if (!axisEvent) {
3225 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3226 }
3227 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3228 }
3229
HandleTouchEventTargetPositionY(const ArkUI_UIInputEvent * event)3230 float HandleTouchEventTargetPositionY(const ArkUI_UIInputEvent* event)
3231 {
3232 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3233 if (!touchEvent) {
3234 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3235 }
3236 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3237 }
3238
OH_ArkUI_UIInputEvent_GetEventTargetPositionY(const ArkUI_UIInputEvent * event)3239 float OH_ArkUI_UIInputEvent_GetEventTargetPositionY(const ArkUI_UIInputEvent* event)
3240 {
3241 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS |
3242 S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE |
3243 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
3244 S_NXC_DISPATCH_AXIS_EVENT,
3245 event);
3246 if (!event) {
3247 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3248 }
3249 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
3250 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetPositionY },
3251 { TOUCH_EVENT_ID, HandleTouchEventTargetPositionY },
3252 { AXIS_EVENT_ID, HandleAxisEventTargetPositionY },
3253 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetPositionY },
3254 { C_AXIS_EVENT_ID, HandleCAxisEventTargetPositionY },
3255 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetPositionY },
3256 { C_HOVER_EVENT_ID, HandleCHoverEventTargetPositionY },
3257 { C_CLICK_EVENT_ID, HandleCClickEventTargetPositionY },
3258 };
3259 auto it = eventHandlers.find(event->eventTypeId);
3260 if (it != eventHandlers.end()) {
3261 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3262 return it->second(inputEvent);
3263 }
3264 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3265 }
3266
HandleCMouseEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3267 float HandleCMouseEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3268 {
3269 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
3270 if (!mouseEvent) {
3271 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3272 }
3273 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3274 }
3275
HandleCTouchEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3276 float HandleCTouchEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3277 {
3278 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3279 if (!touchEvent) {
3280 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3281 }
3282 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3283 }
3284
HandleCHoverEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3285 float HandleCHoverEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3286 {
3287 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3288 if (!hoverEvent) {
3289 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3290 }
3291 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3292 }
3293
HandleCClickEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3294 float HandleCClickEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3295 {
3296 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
3297 if (!clickEvent) {
3298 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3299 }
3300 RETURN_RET_WITH_STATUS_CHECK(clickEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3301 }
3302
HandleCAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3303 float HandleCAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3304 {
3305 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3306 if (!axisEvent) {
3307 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3308 }
3309 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3310 }
3311
HandleCFocusAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3312 float HandleCFocusAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3313 {
3314 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3315 if (!focusAxisEvent) {
3316 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3317 }
3318 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3319 }
3320
HandleAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3321 float HandleAxisEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3322 {
3323 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3324 if (!axisEvent) {
3325 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3326 }
3327 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3328 }
3329
HandleTouchEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3330 float HandleTouchEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3331 {
3332 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3333 if (!touchEvent) {
3334 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3335 }
3336 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetGlobalPositionX, ARKUI_ERROR_CODE_NO_ERROR);
3337 }
3338
OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(const ArkUI_UIInputEvent * event)3339 float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(const ArkUI_UIInputEvent* event)
3340 {
3341 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS |
3342 S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE |
3343 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
3344 S_NXC_DISPATCH_AXIS_EVENT,
3345 event);
3346 if (!event) {
3347 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3348 }
3349 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
3350 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetGlobalPositionX },
3351 { TOUCH_EVENT_ID, HandleTouchEventTargetGlobalPositionX },
3352 { AXIS_EVENT_ID, HandleAxisEventTargetGlobalPositionX },
3353 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetGlobalPositionX },
3354 { C_AXIS_EVENT_ID, HandleCAxisEventTargetGlobalPositionX },
3355 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetGlobalPositionX },
3356 { C_HOVER_EVENT_ID, HandleCHoverEventTargetGlobalPositionX },
3357 { C_CLICK_EVENT_ID, HandleCClickEventTargetGlobalPositionX },
3358 };
3359 auto it = eventHandlers.find(event->eventTypeId);
3360 if (it != eventHandlers.end()) {
3361 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3362 return it->second(inputEvent);
3363 }
3364 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3365 }
3366
HandleCMouseEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3367 float HandleCMouseEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3368 {
3369 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
3370 if (!mouseEvent) {
3371 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3372 }
3373 RETURN_RET_WITH_STATUS_CHECK(mouseEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3374 }
3375
HandleCTouchEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3376 float HandleCTouchEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3377 {
3378 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3379 if (!touchEvent) {
3380 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3381 }
3382 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3383 }
3384
HandleCHoverEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3385 float HandleCHoverEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3386 {
3387 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3388 if (!hoverEvent) {
3389 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3390 }
3391 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3392 }
3393
HandleCClickEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3394 float HandleCClickEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3395 {
3396 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
3397 if (!clickEvent) {
3398 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3399 }
3400 RETURN_RET_WITH_STATUS_CHECK(clickEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3401 }
3402
HandleCAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3403 float HandleCAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3404 {
3405 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3406 if (!axisEvent) {
3407 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3408 }
3409 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3410 }
3411
HandleCFocusAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3412 float HandleCFocusAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3413 {
3414 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3415 if (!focusAxisEvent) {
3416 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3417 }
3418 RETURN_RET_WITH_STATUS_CHECK(focusAxisEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3419 }
3420
HandleAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3421 float HandleAxisEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3422 {
3423 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3424 if (!axisEvent) {
3425 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3426 }
3427 RETURN_RET_WITH_STATUS_CHECK(axisEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3428 }
3429
HandleTouchEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3430 float HandleTouchEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3431 {
3432 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3433 if (!touchEvent) {
3434 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3435 }
3436 RETURN_RET_WITH_STATUS_CHECK(touchEvent->targetGlobalPositionY, ARKUI_ERROR_CODE_NO_ERROR);
3437 }
3438
OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(const ArkUI_UIInputEvent * event)3439 float OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(const ArkUI_UIInputEvent* event)
3440 {
3441 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_FOCUS_AXIS |
3442 S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT | S_NODE_ON_HOVER_MOVE |
3443 S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT | S_GESTURE_MOUSE_EVENT |
3444 S_NXC_DISPATCH_AXIS_EVENT,
3445 event);
3446 if (!event) {
3447 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_CODE_PARAM_INVALID);
3448 }
3449 std::map<ArkUIEventTypeId, std::function<float(ArkUI_UIInputEvent*)>> eventHandlers = {
3450 { C_TOUCH_EVENT_ID, HandleCTouchEventTargetGlobalPositionY },
3451 { TOUCH_EVENT_ID, HandleTouchEventTargetGlobalPositionY },
3452 { AXIS_EVENT_ID, HandleAxisEventTargetGlobalPositionY },
3453 { C_MOUSE_EVENT_ID, HandleCMouseEventTargetGlobalPositionY },
3454 { C_AXIS_EVENT_ID, HandleCAxisEventTargetGlobalPositionY },
3455 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventTargetGlobalPositionY },
3456 { C_HOVER_EVENT_ID, HandleCHoverEventTargetGlobalPositionY },
3457 { C_CLICK_EVENT_ID, HandleCClickEventTargetGlobalPositionY },
3458 };
3459 auto it = eventHandlers.find(event->eventTypeId);
3460 if (it != eventHandlers.end()) {
3461 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3462 return it->second(inputEvent);
3463 }
3464 RETURN_RET_WITH_STATUS_CHECK(0.0f, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3465 }
3466
HandleCMouseEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3467 int32_t HandleCMouseEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3468 {
3469 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
3470 *keys = mouseEvent->modifierKeyState;
3471 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3472 }
3473
HandleCTouchEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3474 int32_t HandleCTouchEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3475 {
3476 const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3477 *keys = touchEvent->modifierKeyState;
3478 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3479 }
3480
HandleCHoverEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3481 int32_t HandleCHoverEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3482 {
3483 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3484 *keys = hoverEvent->modifierKeyState;
3485 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3486 }
3487
HandleCClickEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3488 int32_t HandleCClickEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3489 {
3490 const auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(event->inputEvent);
3491 *keys = clickEvent->modifierKeyState;
3492 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3493 }
3494
HandleCAxisEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3495 int32_t HandleCAxisEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3496 {
3497 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3498 *keys = axisEvent->modifierKeyState;
3499 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3500 }
3501
HandleCKeyEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3502 int32_t HandleCKeyEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3503 {
3504 const auto* keyEvent = reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent);
3505 *keys = keyEvent->modifierKeyState;
3506 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3507 }
3508
HandleCFocusAxisEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3509 int32_t HandleCFocusAxisEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3510 {
3511 const auto* focusAxisEvent = reinterpret_cast<ArkUIFocusAxisEvent*>(event->inputEvent);
3512 *keys = focusAxisEvent->modifierKeyState;
3513 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3514 }
3515
HandleAxisEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3516 int32_t HandleAxisEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3517 {
3518 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3519 *keys = axisEvent->modifierKeyState;
3520 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3521 }
3522
HandleTouchEventModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3523 int32_t HandleTouchEventModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3524 {
3525 const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
3526 *keys = touchEvent->modifierKeyState;
3527 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3528 }
3529
OH_ArkUI_UIInputEvent_GetModifierKeyStates(const ArkUI_UIInputEvent * event,uint64_t * keys)3530 int32_t OH_ArkUI_UIInputEvent_GetModifierKeyStates(const ArkUI_UIInputEvent* event, uint64_t* keys)
3531 {
3532 const int32_t supportedScenario = S_NODE_TOUCH_EVENT | S_NODE_ON_MOUSE | S_NODE_ON_KEY_EVENT |
3533 S_NODE_ON_FOCUS_AXIS | S_NODE_ON_CLICK_EVENT | S_NODE_ON_HOVER_EVENT |
3534 S_NODE_ON_HOVER_MOVE | S_GESTURE_TOUCH_EVENT | S_GESTURE_AXIS_EVENT |
3535 S_GESTURE_MOUSE_EVENT | S_NXC_ON_TOUCH_INTERCEPT | S_NXC_DISPATCH_AXIS_EVENT;
3536 CheckSupportedScenarioAndResetEventStatus(supportedScenario, event);
3537 if (!event || !keys) {
3538 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3539 }
3540 std::map<ArkUIEventTypeId, std::function<int32_t(ArkUI_UIInputEvent*, uint64_t*)>> eventHandlers = {
3541 { C_TOUCH_EVENT_ID, HandleCTouchEventModifierKeyStates },
3542 { TOUCH_EVENT_ID, HandleTouchEventModifierKeyStates },
3543 { AXIS_EVENT_ID, HandleAxisEventModifierKeyStates },
3544 { C_MOUSE_EVENT_ID, HandleCMouseEventModifierKeyStates },
3545 { C_AXIS_EVENT_ID, HandleCAxisEventModifierKeyStates },
3546 { C_KEY_EVENT_ID, HandleCKeyEventModifierKeyStates },
3547 { C_FOCUS_AXIS_EVENT_ID, HandleCFocusAxisEventModifierKeyStates },
3548 { C_HOVER_EVENT_ID, HandleCHoverEventModifierKeyStates },
3549 { C_CLICK_EVENT_ID, HandleCClickEventModifierKeyStates },
3550 };
3551 auto it = eventHandlers.find(event->eventTypeId);
3552 if (it != eventHandlers.end()) {
3553 ArkUI_UIInputEvent* inputEvent = const_cast<ArkUI_UIInputEvent*>(event);
3554 uint64_t* inputkeys = const_cast<uint64_t*>(keys);
3555 return it->second(inputEvent, inputkeys);
3556 }
3557 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3558 }
3559
OH_ArkUI_HoverEvent_IsHovered(const ArkUI_UIInputEvent * event)3560 bool OH_ArkUI_HoverEvent_IsHovered(const ArkUI_UIInputEvent* event)
3561 {
3562 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_HOVER_EVENT, event);
3563 if (!event) {
3564 RETURN_RET_WITH_STATUS_CHECK(false, ARKUI_ERROR_CODE_PARAM_INVALID);
3565 }
3566 switch (event->eventTypeId) {
3567 case C_HOVER_EVENT_ID: {
3568 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(event->inputEvent);
3569 if (!hoverEvent) {
3570 RETURN_RET_WITH_STATUS_CHECK(false, ARKUI_ERROR_CODE_PARAM_INVALID);
3571 }
3572 RETURN_RET_WITH_STATUS_CHECK(hoverEvent->isHover, ARKUI_ERROR_CODE_NO_ERROR);
3573 }
3574 default:
3575 break;
3576 }
3577 RETURN_RET_WITH_STATUS_CHECK(false, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3578 }
3579
OH_ArkUI_AxisEvent_SetPropagation(const ArkUI_UIInputEvent * event,bool propagation)3580 int32_t OH_ArkUI_AxisEvent_SetPropagation(const ArkUI_UIInputEvent* event, bool propagation)
3581 {
3582 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_AXIS, event);
3583 if (!event) {
3584 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3585 }
3586 switch (event->eventTypeId) {
3587 case C_AXIS_EVENT_ID: {
3588 auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3589 if (axisEvent) {
3590 axisEvent->propagation = propagation;
3591 break;
3592 }
3593 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3594 }
3595 default:
3596 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3597 }
3598 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3599 }
3600
OH_ArkUI_AxisEvent_GetScrollStep(const ArkUI_UIInputEvent * event)3601 int32_t OH_ArkUI_AxisEvent_GetScrollStep(const ArkUI_UIInputEvent* event)
3602 {
3603 CheckSupportedScenarioAndResetEventStatus(S_NODE_ON_AXIS | S_GESTURE_AXIS_EVENT | S_NXC_DISPATCH_AXIS_EVENT, event);
3604 int32_t scroll_step_value = 0;
3605
3606 if (!event) {
3607 RETURN_RET_WITH_STATUS_CHECK(scroll_step_value, ARKUI_ERROR_CODE_PARAM_INVALID);
3608 }
3609 switch (event->eventTypeId) {
3610 case AXIS_EVENT_ID: {
3611 const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
3612 if (axisEvent) {
3613 scroll_step_value = axisEvent->scrollStep;
3614 }
3615 break;
3616 }
3617 case C_AXIS_EVENT_ID: {
3618 const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
3619 if (axisEvent) {
3620 scroll_step_value = axisEvent->scrollStep;
3621 }
3622 break;
3623 }
3624 default:
3625 RETURN_RET_WITH_STATUS_CHECK(scroll_step_value, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3626 }
3627 RETURN_RET_WITH_STATUS_CHECK(scroll_step_value, ARKUI_ERROR_CODE_NO_ERROR);
3628 }
3629
OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent * event,ArkUI_UIInputEvent ** clonedEvent)3630 int32_t OH_ArkUI_PointerEvent_CreateClonedEvent(const ArkUI_UIInputEvent* event, ArkUI_UIInputEvent** clonedEvent)
3631 {
3632 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3633 if (!event) {
3634 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3635 }
3636 if (!clonedEvent) {
3637 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3638 }
3639 switch (event->eventTypeId) {
3640 case TOUCH_EVENT_ID:
3641 case C_TOUCH_EVENT_ID: {
3642 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3643 if (!touchEvent) {
3644 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3645 }
3646 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
3647 if (!fullImpl) {
3648 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3649 }
3650 ArkUI_UIInputEvent* currentEvent = new ArkUI_UIInputEvent();
3651 currentEvent->inputType = event->inputType;
3652 currentEvent->eventTypeId = event->eventTypeId;
3653 ArkUITouchEvent* touchEventCloned = new ArkUITouchEvent();
3654 fullImpl->getNodeModifiers()->getCommonModifier()->createClonedTouchEvent(touchEventCloned, touchEvent);
3655 currentEvent->inputEvent = touchEventCloned;
3656 currentEvent->isCloned = true;
3657 *clonedEvent = currentEvent;
3658 break;
3659 }
3660 default: {
3661 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT);
3662 }
3663 }
3664 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3665 }
3666
OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent * event)3667 int32_t OH_ArkUI_PointerEvent_DestroyClonedEvent(const ArkUI_UIInputEvent* event)
3668 {
3669 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3670 if (!event) {
3671 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3672 }
3673 if (!event->isCloned) {
3674 RETURN_RET_WITH_STATUS_CHECK(
3675 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3676 }
3677 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3678 if (touchEvent) {
3679 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
3680 fullImpl->getNodeModifiers()->getCommonModifier()->destroyTouchEvent(touchEvent);
3681 }
3682 delete event;
3683 event = nullptr;
3684 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3685 }
3686
OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent * event,float x,float y)3687 int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(const ArkUI_UIInputEvent* event, float x, float y)
3688 {
3689 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3690 if (!event) {
3691 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3692 }
3693 if (!event->isCloned) {
3694 RETURN_RET_WITH_STATUS_CHECK(
3695 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3696 }
3697 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3698 if (!touchEvent) {
3699 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3700 }
3701 touchEvent->actionTouchPoint.nodeX = x;
3702 touchEvent->actionTouchPoint.nodeY = y;
3703 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3704 }
3705
OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(const ArkUI_UIInputEvent * event,float x,float y,int32_t pointerIndex)3706 int32_t OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(
3707 const ArkUI_UIInputEvent* event, float x, float y, int32_t pointerIndex)
3708 {
3709 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3710 if (!event) {
3711 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3712 }
3713 if (!event->isCloned) {
3714 RETURN_RET_WITH_STATUS_CHECK(
3715 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3716 }
3717 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3718 if (!touchEvent) {
3719 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3720 }
3721 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
3722 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3723 }
3724 touchEvent->touchPointes[pointerIndex].nodeX = x;
3725 touchEvent->touchPointes[pointerIndex].nodeY = y;
3726 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3727 }
3728
OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent * event,int32_t actionType)3729 int32_t OH_ArkUI_PointerEvent_SetClonedEventActionType(const ArkUI_UIInputEvent* event, int32_t actionType)
3730 {
3731 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3732 if (!event) {
3733 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3734 }
3735 if (!event->isCloned) {
3736 RETURN_RET_WITH_STATUS_CHECK(
3737 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3738 }
3739 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3740 if (!touchEvent) {
3741 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3742 }
3743 touchEvent->action = OHOS::Ace::NodeModel::ConvertToOriginTouchActionType(actionType);
3744 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3745 }
3746
OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent * event,int32_t fingerId)3747 int32_t OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(const ArkUI_UIInputEvent* event, int32_t fingerId)
3748 {
3749 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3750 if (!event) {
3751 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3752 }
3753 if (!event->isCloned) {
3754 RETURN_RET_WITH_STATUS_CHECK(
3755 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3756 }
3757 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3758 if (!touchEvent) {
3759 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3760 }
3761 touchEvent->actionTouchPoint.id = fingerId;
3762 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3763 }
3764
OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(const ArkUI_UIInputEvent * event,int32_t fingerId,int32_t pointerIndex)3765 int32_t OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(
3766 const ArkUI_UIInputEvent* event, int32_t fingerId, int32_t pointerIndex)
3767 {
3768 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3769 if (!event) {
3770 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3771 }
3772 if (!event->isCloned) {
3773 RETURN_RET_WITH_STATUS_CHECK(
3774 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3775 }
3776 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3777 if (!touchEvent) {
3778 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3779 }
3780 if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
3781 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3782 }
3783 touchEvent->touchPointes[pointerIndex].id = fingerId;
3784 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_NO_ERROR, ARKUI_ERROR_CODE_NO_ERROR);
3785 }
3786
OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node,const ArkUI_UIInputEvent * event)3787 int32_t OH_ArkUI_PointerEvent_PostClonedEvent(ArkUI_NodeHandle node, const ArkUI_UIInputEvent* event)
3788 {
3789 CheckSupportedScenarioAndResetEventStatus(S_NODE_TOUCH_EVENT, event);
3790 if (!event) {
3791 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3792 }
3793 if (!node) {
3794 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL,
3795 ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL);
3796 }
3797 if (!event->isCloned) {
3798 RETURN_RET_WITH_STATUS_CHECK(
3799 ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT);
3800 }
3801 auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
3802 if (!touchEvent) {
3803 RETURN_RET_WITH_STATUS_CHECK(OHOS::Ace::ERROR_CODE_PARAM_INVALID, ARKUI_ERROR_CODE_PARAM_INVALID);
3804 }
3805 auto fullImpl = OHOS::Ace::NodeModel::GetFullImpl();
3806 if (!fullImpl) {
3807 RETURN_RET_WITH_STATUS_CHECK(ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL,
3808 ARKUI_ERROR_CODE_POST_CLONED_COMPONENT_STATUS_ABNORMAL);
3809 }
3810 int32_t res = fullImpl->getNodeModifiers()->getCommonModifier()->postTouchEvent(node->uiNodeHandle, touchEvent);
3811 RETURN_RET_WITH_STATUS_CHECK(res, ARKUI_ERROR_CODE_NO_ERROR);
3812 }
3813
IsTouchEventSupportedScenario(uint32_t scenarioExpr,const ArkUITouchEvent * touchEvent)3814 ArkUI_ErrorCode IsTouchEventSupportedScenario(uint32_t scenarioExpr, const ArkUITouchEvent* touchEvent)
3815 {
3816 if (!touchEvent) {
3817 return ARKUI_ERROR_CODE_PARAM_INVALID;
3818 }
3819 bool support = false;
3820 if (touchEvent->subKind == ON_TOUCH) {
3821 // mouse event registed by NODE_ON_TOUCH
3822 support = scenarioExpr & S_NODE_TOUCH_EVENT;
3823 } else if (touchEvent->subKind == ON_TOUCH_INTERCEPT) {
3824 // key event registed by NODE_ON_TOUCH_INTERCEPT
3825 support = scenarioExpr & S_NODE_ON_TOUCH_INTERCEPT;
3826 } else if (touchEvent->subKind == ON_HOVER_MOVE) {
3827 // key event registed by NODE_ON_HOVER_MOVE
3828 support = scenarioExpr & S_NODE_ON_HOVER_MOVE;
3829 } else {
3830 // gesture triggered by touch
3831 support = scenarioExpr & S_GESTURE_TOUCH_EVENT;
3832 }
3833 return support ? ARKUI_ERROR_CODE_NO_ERROR : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3834 }
3835
IsMouseEventSupportedScenario(uint32_t scenarioExpr,const ArkUIMouseEvent * mouseEvent)3836 ArkUI_ErrorCode IsMouseEventSupportedScenario(uint32_t scenarioExpr, const ArkUIMouseEvent* mouseEvent)
3837 {
3838 if (!mouseEvent) {
3839 return ARKUI_ERROR_CODE_PARAM_INVALID;
3840 }
3841 bool support = false;
3842 if (mouseEvent->subKind == ON_MOUSE) {
3843 // mouse event registed by NODE_ON_MOUSE
3844 support = scenarioExpr & S_NODE_ON_MOUSE;
3845 } else {
3846 // gesture triggered by mouse
3847 support = scenarioExpr & S_GESTURE_MOUSE_EVENT;
3848 }
3849 return support ? ARKUI_ERROR_CODE_NO_ERROR : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3850 }
3851
IsAxisEventSupportedScenario(uint32_t scenarioExpr,const ArkUIAxisEvent * axisEvent)3852 ArkUI_ErrorCode IsAxisEventSupportedScenario(uint32_t scenarioExpr, const ArkUIAxisEvent* axisEvent)
3853 {
3854 if (!axisEvent) {
3855 return ARKUI_ERROR_CODE_PARAM_INVALID;
3856 }
3857 bool support = false;
3858 if (axisEvent->subKind == ON_AXIS) {
3859 // axis event registed by NODE_ON_AXIS
3860 support = scenarioExpr & S_NODE_ON_AXIS;
3861 } else {
3862 // gesture triggered by axis
3863 support = scenarioExpr & S_GESTURE_AXIS_EVENT;
3864 }
3865 return support ? ARKUI_ERROR_CODE_NO_ERROR : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3866 }
3867
IsKeyEventSupportedScenario(uint32_t scenarioExpr,const ArkUIKeyEvent * keyEvent)3868 ArkUI_ErrorCode IsKeyEventSupportedScenario(uint32_t scenarioExpr, const ArkUIKeyEvent* keyEvent)
3869 {
3870 if (!keyEvent) {
3871 return ARKUI_ERROR_CODE_PARAM_INVALID;
3872 }
3873 bool support = false;
3874 if (keyEvent->subKind == ON_KEY_EVENT) {
3875 // key event registed by NODE_ON_KEY_EVENT
3876 support = scenarioExpr & S_NODE_ON_KEY_EVENT;
3877 } else if (keyEvent->subKind == ON_KEY_PREIME) {
3878 // key event registed by NODE_ON_KEY_PREIME
3879 support = scenarioExpr & S_NODE_ON_KEY_PRE_IME;
3880 } else {
3881 // key event registed by NODE_NODE_DISPATCH_KEY_EVENT
3882 support = scenarioExpr & S_NODE_DISPATCH_KEY_EVENT;
3883 }
3884 return support ? ARKUI_ERROR_CODE_NO_ERROR : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3885 }
3886
CheckIsSupportedScenario(uint32_t scenarioExpr,const ArkUI_UIInputEvent * event)3887 ArkUI_ErrorCode CheckIsSupportedScenario(uint32_t scenarioExpr, const ArkUI_UIInputEvent* event)
3888 {
3889 if (!event) {
3890 return ARKUI_ERROR_CODE_PARAM_INVALID;
3891 }
3892 switch (event->eventTypeId) {
3893 case AXIS_EVENT_ID: {
3894 // axis event from nativeXComponent
3895 return scenarioExpr & S_NXC_DISPATCH_AXIS_EVENT ? ARKUI_ERROR_CODE_NO_ERROR
3896 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3897 }
3898 case TOUCH_EVENT_ID: {
3899 // touch intercept from nativeXComponent
3900 return scenarioExpr & S_NXC_ON_TOUCH_INTERCEPT ? ARKUI_ERROR_CODE_NO_ERROR
3901 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3902 }
3903 case C_TOUCH_EVENT_ID: {
3904 return IsTouchEventSupportedScenario(scenarioExpr, reinterpret_cast<ArkUITouchEvent*>(event->inputEvent));
3905 }
3906 case C_MOUSE_EVENT_ID: {
3907 return IsMouseEventSupportedScenario(scenarioExpr, reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent));
3908 }
3909 case C_AXIS_EVENT_ID: {
3910 return IsAxisEventSupportedScenario(scenarioExpr, reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent));
3911 }
3912 case C_KEY_EVENT_ID: {
3913 return IsKeyEventSupportedScenario(scenarioExpr, reinterpret_cast<ArkUIKeyEvent*>(event->inputEvent));
3914 }
3915 case C_FOCUS_AXIS_EVENT_ID: {
3916 // focus axis event registed by NODE_ON_FOCUS_AXIS
3917 return scenarioExpr & S_NODE_ON_FOCUS_AXIS ? ARKUI_ERROR_CODE_NO_ERROR
3918 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3919 }
3920 case C_CLICK_EVENT_ID: {
3921 if (event->inputType == ARKUI_UIINPUTEVENT_TYPE_KEY) {
3922 // click event from click or tap gesture triggered by keyboard
3923 return scenarioExpr & S_GESTURE_CLICK_EVENT ? ARKUI_ERROR_CODE_NO_ERROR
3924 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3925 } else {
3926 // click event registed by NODE_ON_CLICK
3927 return scenarioExpr & S_NODE_ON_CLICK_EVENT ? ARKUI_ERROR_CODE_NO_ERROR
3928 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3929 }
3930 }
3931 case C_HOVER_EVENT_ID: {
3932 // hover event registed by NODE_ON_HOVER_EVENT
3933 return scenarioExpr & S_NODE_ON_HOVER_EVENT ? ARKUI_ERROR_CODE_NO_ERROR
3934 : ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3935 }
3936 default: {
3937 LOGE("received event with unknown eventType");
3938 }
3939 }
3940 return ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT;
3941 }
3942
OH_ArkUI_UIInputEvent_GetLatestStatus()3943 ArkUI_ErrorCode OH_ArkUI_UIInputEvent_GetLatestStatus()
3944 {
3945 return g_latestEventStatus;
3946 }
3947
3948 #ifdef __cplusplus
3949 };
3950 #endif
3951