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 "base/error/error_code.h"
21
22#ifdef __cplusplus
23extern "C" {
24#endif
25bool isCurrentCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t pointerIndex)
26{
27    if (!touchEvent) {
28        return false;
29    }
30    if ((pointerIndex < 0 || pointerIndex >= touchEvent->touchPointSize) ||
31        !(touchEvent->touchPointes)) {
32        return false;
33    }
34    return true;
35}
36
37bool isHistoryCTouchEventParamValid(const ArkUITouchEvent* touchEvent, uint32_t historyIndex, uint32_t pointerIndex)
38{
39    if (!touchEvent) {
40        return false;
41    }
42    if ((historyIndex < 0 || historyIndex >= touchEvent->historySize) ||
43        !touchEvent->historyEvents) {
44        return false;
45    }
46    if ((pointerIndex < 0 || pointerIndex >= touchEvent->historyEvents[historyIndex].touchPointSize) ||
47        !(touchEvent->historyEvents[historyIndex].touchPointes)) {
48        return false;
49    }
50    return true;
51}
52
53int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
54{
55    if (!event) {
56        return 0;
57    }
58    return event->inputType;
59}
60
61int32_t OH_ArkUI_UIInputEvent_GetAction(const ArkUI_UIInputEvent* event)
62{
63    if (!event) {
64        return -1;
65    }
66    switch (event->eventTypeId) {
67        case C_TOUCH_EVENT_ID: {
68            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
69            if (!touchEvent) {
70                return -1;
71            }
72            return OHOS::Ace::NodeModel::ConvertToCTouchActionType(touchEvent->action);
73        }
74        case C_MOUSE_EVENT_ID: {
75            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
76            if (!mouseEvent) {
77                return -1;
78            }
79            return OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action);
80        }
81        default:
82            break;
83    }
84    return -1;
85}
86
87int32_t OH_ArkUI_UIInputEvent_GetSourceType(const ArkUI_UIInputEvent* event)
88{
89    if (!event) {
90        return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
91    }
92    switch (event->eventTypeId) {
93        case C_TOUCH_EVENT_ID: {
94            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
95            if (!touchEvent) {
96                return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
97            }
98            return touchEvent->sourceType;
99        }
100        case C_MOUSE_EVENT_ID: {
101            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
102            if (!mouseEvent) {
103                return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
104            }
105            return mouseEvent->sourceType;
106        }
107        case C_AXIS_EVENT_ID: {
108            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
109            if (!axisEvent) {
110                return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
111            }
112            return axisEvent->sourceType;
113        }
114        default:
115            break;
116    }
117    return static_cast<int32_t>(UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN);
118}
119
120int32_t OH_ArkUI_UIInputEvent_GetToolType(const ArkUI_UIInputEvent* event)
121{
122    if (!event) {
123        return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
124    }
125    switch (event->eventTypeId) {
126        case C_TOUCH_EVENT_ID: {
127            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
128            if (!touchEvent) {
129                return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
130            }
131            return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(touchEvent->actionTouchPoint.toolType);
132        }
133        case C_MOUSE_EVENT_ID: {
134            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
135            if (!mouseEvent) {
136                return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
137            }
138            return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(mouseEvent->actionTouchPoint.toolType);
139        }
140        case C_AXIS_EVENT_ID: {
141            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
142            if (!axisEvent) {
143                return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
144            }
145            return OHOS::Ace::NodeModel::ConvertToCInputEventToolType(axisEvent->actionTouchPoint.toolType);
146        }
147        default:
148            break;
149    }
150    return static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN);
151}
152
153int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)
154{
155    if (!event) {
156        return 0;
157    }
158    switch (event->eventTypeId) {
159        case C_TOUCH_EVENT_ID: {
160            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
161            if (!touchEvent) {
162                return 0;
163            }
164            return touchEvent->timeStamp;
165        }
166        case TOUCH_EVENT_ID: {
167            const auto* uiEvent = reinterpret_cast<const OHOS::Ace::UIInputEvent*>(event->inputEvent);
168            if (!uiEvent) {
169                LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
170                return 0;
171            }
172            return uiEvent->time.time_since_epoch().count();
173        }
174        case AXIS_EVENT_ID: {
175            const auto* uiEvent = reinterpret_cast<const OHOS::Ace::UIInputEvent*>(event->inputEvent);
176            if (!uiEvent) {
177                LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
178                return 0;
179            }
180            return uiEvent->time.time_since_epoch().count();
181        }
182        case C_MOUSE_EVENT_ID: {
183            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
184            if (!mouseEvent) {
185                return 0;
186            }
187            return mouseEvent->timeStamp;
188        }
189        case C_AXIS_EVENT_ID: {
190            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
191            if (!axisEvent) {
192                return 0;
193            }
194            return axisEvent->timeStamp;
195        }
196        default:
197            break;
198    }
199    return 0;
200}
201
202uint32_t OH_ArkUI_PointerEvent_GetPointerCount(const ArkUI_UIInputEvent* event)
203{
204    if (!event) {
205        return 0;
206    }
207    switch (event->eventTypeId) {
208        case C_TOUCH_EVENT_ID: {
209            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
210            if (!touchEvent) {
211                return 0;
212            }
213            return touchEvent->touchPointSize;
214        }
215        case C_MOUSE_EVENT_ID: {
216            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
217            if (!mouseEvent) {
218                return 0;
219            }
220            return 1;
221        }
222        case C_AXIS_EVENT_ID: {
223            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
224            if (!axisEvent) {
225                return 0;
226            }
227            return 1;
228        }
229        default:
230            break;
231    }
232    return 0;
233}
234
235int32_t OH_ArkUI_PointerEvent_GetPointerId(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
236{
237    if (!event) {
238        return 0;
239    }
240    switch (event->eventTypeId) {
241        case C_TOUCH_EVENT_ID: {
242            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
243            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
244                return 0;
245            }
246            return touchEvent->touchPointes[pointerIndex].id;
247        }
248        case C_MOUSE_EVENT_ID: {
249            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
250            if (!mouseEvent || pointerIndex != 0) {
251                return 0;
252            }
253            return mouseEvent->actionTouchPoint.id;
254        }
255        case C_AXIS_EVENT_ID: {
256            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
257            if (!axisEvent || pointerIndex != 0) {
258                return 0;
259            }
260            return axisEvent->actionTouchPoint.id;
261        }
262        default:
263            break;
264    }
265    return 0;
266}
267
268float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)
269{
270    if (!event) {
271        return 0.0f;
272    }
273    switch (event->eventTypeId) {
274        case C_TOUCH_EVENT_ID: {
275            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
276            if (!touchEvent) {
277                return 0.0f;
278            }
279            return touchEvent->actionTouchPoint.nodeX;
280        }
281        case TOUCH_EVENT_ID: {
282            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
283            if (touchEvent) {
284                return touchEvent->localX;
285            }
286            break;
287        }
288        case AXIS_EVENT_ID: {
289            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
290            if (axisEvent) {
291                return axisEvent->localX;
292            }
293            break;
294        }
295        case C_MOUSE_EVENT_ID: {
296            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
297            if (!mouseEvent) {
298                return 0.0f;
299            }
300            return mouseEvent->actionTouchPoint.nodeX;
301        }
302        case C_AXIS_EVENT_ID: {
303            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
304            if (!axisEvent) {
305                return 0.0f;
306            }
307            return axisEvent->actionTouchPoint.nodeX;
308        }
309        default:
310            break;
311    }
312    return 0.0f;
313}
314
315float OH_ArkUI_PointerEvent_GetXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
316{
317    if (!event) {
318        return 0.0f;
319    }
320    switch (event->eventTypeId) {
321        case C_TOUCH_EVENT_ID: {
322            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
323            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
324                return 0.0f;
325            }
326            return touchEvent->touchPointes[pointerIndex].nodeX;
327        }
328        case C_MOUSE_EVENT_ID: {
329            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
330            if (!mouseEvent || pointerIndex != 0) {
331                return 0.0f;
332            }
333            return mouseEvent->actionTouchPoint.nodeX;
334        }
335        case C_AXIS_EVENT_ID: {
336            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
337            if (!axisEvent || pointerIndex != 0) {
338                return 0.0f;
339            }
340            return axisEvent->actionTouchPoint.nodeX;
341        }
342        default:
343            break;
344    }
345    return 0.0f;
346}
347
348float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)
349{
350    if (!event) {
351        return 0.0f;
352    }
353    switch (event->eventTypeId) {
354        case C_TOUCH_EVENT_ID: {
355            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
356            if (!touchEvent) {
357                return 0.0f;
358            }
359            return touchEvent->actionTouchPoint.nodeY;
360        }
361        case TOUCH_EVENT_ID: {
362            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
363            if (touchEvent) {
364                return touchEvent->localY;
365            }
366            break;
367        }
368        case AXIS_EVENT_ID: {
369            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
370            if (axisEvent) {
371                return axisEvent->localY;
372            }
373            break;
374        }
375        case C_MOUSE_EVENT_ID: {
376            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
377            if (!mouseEvent) {
378                return 0.0f;
379            }
380            return mouseEvent->actionTouchPoint.nodeY;
381        }
382        case C_AXIS_EVENT_ID: {
383            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
384            if (!axisEvent) {
385                return 0.0f;
386            }
387            return axisEvent->actionTouchPoint.nodeY;
388        }
389        default:
390            break;
391    }
392    LOGE("The parameter of OH_ArkUI_PointerEvent_GetY is invalid");
393    return 0.0f;
394}
395
396float OH_ArkUI_PointerEvent_GetYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
397{
398    if (!event) {
399        return 0.0f;
400    }
401    switch (event->eventTypeId) {
402        case C_TOUCH_EVENT_ID: {
403            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
404            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
405                return 0.0f;
406            }
407            return touchEvent->touchPointes[pointerIndex].nodeY;
408        }
409        case C_MOUSE_EVENT_ID: {
410            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
411            if (!mouseEvent || pointerIndex != 0) {
412                return 0.0f;
413            }
414            return mouseEvent->actionTouchPoint.nodeY;
415        }
416        case C_AXIS_EVENT_ID: {
417            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
418            if (!axisEvent || pointerIndex != 0) {
419                return 0.0f;
420            }
421            return axisEvent->actionTouchPoint.nodeY;
422        }
423        default:
424            break;
425    }
426    return 0.0f;
427}
428
429float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
430{
431    if (!event) {
432        return 0.0f;
433    }
434    switch (event->eventTypeId) {
435        case C_TOUCH_EVENT_ID: {
436            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
437            if (!touchEvent) {
438                return 0.0f;
439            }
440            return touchEvent->actionTouchPoint.windowX;
441        }
442        case TOUCH_EVENT_ID: {
443            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
444            if (touchEvent) {
445                return touchEvent->x;
446            }
447            break;
448        }
449        case AXIS_EVENT_ID: {
450            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
451            if (axisEvent) {
452                return axisEvent->x;
453            }
454            break;
455        }
456        case C_MOUSE_EVENT_ID: {
457            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
458            if (!mouseEvent) {
459                return 0.0f;
460            }
461            return mouseEvent->actionTouchPoint.windowX;
462        }
463        case C_AXIS_EVENT_ID: {
464            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
465            if (!axisEvent) {
466                return 0.0f;
467            }
468            return axisEvent->actionTouchPoint.windowX;
469        }
470        default:
471            break;
472    }
473    LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowX is invalid");
474    return 0.0f;
475}
476
477float OH_ArkUI_PointerEvent_GetWindowXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
478{
479    if (!event) {
480        return 0.0f;
481    }
482    switch (event->eventTypeId) {
483        case C_TOUCH_EVENT_ID: {
484            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
485            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
486                return 0.0f;
487            }
488            return touchEvent->touchPointes[pointerIndex].windowX;
489        }
490        case C_MOUSE_EVENT_ID: {
491            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
492            if (!mouseEvent || pointerIndex != 0) {
493                return 0.0f;
494            }
495            return mouseEvent->actionTouchPoint.windowX;
496        }
497        case C_AXIS_EVENT_ID: {
498            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
499            if (!axisEvent || pointerIndex != 0) {
500                return 0.0f;
501            }
502            return axisEvent->actionTouchPoint.windowX;
503        }
504        default:
505            break;
506    }
507    return 0.0f;
508}
509
510float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
511{
512    if (!event) {
513        return 0.0f;
514    }
515    switch (event->eventTypeId) {
516        case C_TOUCH_EVENT_ID: {
517            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
518            if (!touchEvent) {
519                return 0.0f;
520            }
521            return touchEvent->actionTouchPoint.windowY;
522        }
523        case TOUCH_EVENT_ID: {
524            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
525            if (touchEvent) {
526                return touchEvent->y;
527            }
528            break;
529        }
530        case AXIS_EVENT_ID: {
531            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
532            if (axisEvent) {
533                return axisEvent->y;
534            }
535            break;
536        }
537        case C_MOUSE_EVENT_ID: {
538            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
539            if (!mouseEvent) {
540                return 0.0f;
541            }
542            return mouseEvent->actionTouchPoint.windowY;
543        }
544        case C_AXIS_EVENT_ID: {
545            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
546            if (!axisEvent) {
547                return 0.0f;
548            }
549            return axisEvent->actionTouchPoint.windowY;
550        }
551        default:
552            break;
553    }
554    LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowY is invalid");
555    return 0.0f;
556}
557
558float OH_ArkUI_PointerEvent_GetWindowYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
559{
560    if (!event) {
561        return 0.0f;
562    }
563    switch (event->eventTypeId) {
564        case C_TOUCH_EVENT_ID: {
565            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
566            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
567                return 0.0f;
568            }
569            return touchEvent->touchPointes[pointerIndex].windowY;
570        }
571        case C_MOUSE_EVENT_ID: {
572            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
573            if (!mouseEvent || pointerIndex != 0) {
574                return 0.0f;
575            }
576            return mouseEvent->actionTouchPoint.windowY;
577        }
578        case C_AXIS_EVENT_ID: {
579            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
580            if (!axisEvent || pointerIndex != 0) {
581                return 0.0f;
582            }
583            return axisEvent->actionTouchPoint.windowY;
584        }
585        default:
586            break;
587    }
588    return 0.0f;
589}
590
591float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
592{
593    if (!event) {
594        return 0.0f;
595    }
596    switch (event->eventTypeId) {
597        case C_TOUCH_EVENT_ID: {
598            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
599            if (!touchEvent) {
600                return 0.0f;
601            }
602            return touchEvent->actionTouchPoint.screenX;
603        }
604        case TOUCH_EVENT_ID: {
605            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
606            if (touchEvent) {
607                return touchEvent->screenX;
608            }
609            break;
610        }
611        case AXIS_EVENT_ID: {
612            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
613            if (axisEvent) {
614                return axisEvent->screenX;
615            }
616            break;
617        }
618        case C_MOUSE_EVENT_ID: {
619            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
620            if (!mouseEvent) {
621                return 0.0f;
622            }
623            return mouseEvent->actionTouchPoint.screenX;
624        }
625        case C_AXIS_EVENT_ID: {
626            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
627            if (!axisEvent) {
628                return 0.0f;
629            }
630            return axisEvent->actionTouchPoint.screenX;
631        }
632        default:
633            break;
634    }
635    LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayX is invalid");
636    return 0.0f;
637}
638
639float OH_ArkUI_PointerEvent_GetDisplayXByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
640{
641    if (!event) {
642        return 0.0f;
643    }
644    switch (event->eventTypeId) {
645        case C_TOUCH_EVENT_ID: {
646            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
647            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
648                return 0.0f;
649            }
650            return touchEvent->touchPointes[pointerIndex].screenX;
651        }
652        case C_MOUSE_EVENT_ID: {
653            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
654            if (!mouseEvent || pointerIndex != 0) {
655                return 0.0f;
656            }
657            return mouseEvent->actionTouchPoint.screenX;
658        }
659        case C_AXIS_EVENT_ID: {
660            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
661            if (!axisEvent || pointerIndex != 0) {
662                return 0.0f;
663            }
664            return axisEvent->actionTouchPoint.screenX;
665        }
666        default:
667            break;
668    }
669    return 0.0f;
670}
671
672float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
673{
674    if (!event) {
675        return 0.0f;
676    }
677    switch (event->eventTypeId) {
678        case C_TOUCH_EVENT_ID: {
679            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
680            if (!touchEvent) {
681                return 0.0f;
682            }
683            return touchEvent->actionTouchPoint.screenY;
684        }
685        case TOUCH_EVENT_ID: {
686            const auto* touchEvent = reinterpret_cast<const OHOS::Ace::TouchEvent*>(event->inputEvent);
687            if (touchEvent) {
688                return touchEvent->screenY;
689            }
690            break;
691        }
692        case AXIS_EVENT_ID: {
693            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
694            if (axisEvent) {
695                return axisEvent->screenY;
696            }
697            break;
698        }
699        case C_MOUSE_EVENT_ID: {
700            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
701            if (!mouseEvent) {
702                return 0.0f;
703            }
704            return mouseEvent->actionTouchPoint.screenY;
705        }
706        case C_AXIS_EVENT_ID: {
707            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
708            if (!axisEvent) {
709                return 0.0f;
710            }
711            return axisEvent->actionTouchPoint.screenY;
712        }
713        default:
714            break;
715    }
716    LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayY is invalid");
717    return 0.0f;
718}
719
720float OH_ArkUI_PointerEvent_GetDisplayYByIndex(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
721{
722    if (!event) {
723        return 0.0f;
724    }
725    switch (event->eventTypeId) {
726        case C_TOUCH_EVENT_ID: {
727            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
728            if (!isCurrentCTouchEventParamValid(touchEvent, pointerIndex)) {
729                return 0.0f;
730            }
731            return touchEvent->touchPointes[pointerIndex].screenY;
732        }
733        case C_MOUSE_EVENT_ID: {
734            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
735            if (!mouseEvent || pointerIndex != 0) {
736                return 0.0f;
737            }
738            return mouseEvent->actionTouchPoint.screenY;
739        }
740        case C_AXIS_EVENT_ID: {
741            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
742            if (!axisEvent || pointerIndex != 0) {
743                return 0.0f;
744            }
745            return axisEvent->actionTouchPoint.screenY;
746        }
747        default:
748            break;
749    }
750    return 0.0f;
751}
752
753float OH_ArkUI_PointerEvent_GetPressure(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
754{
755    if (!event) {
756        return 0.0f;
757    }
758    switch (event->eventTypeId) {
759        case C_TOUCH_EVENT_ID: {
760            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
761            if (!touchEvent || touchEvent->touchPointSize <= 0) {
762                return 0.0f;
763            }
764            return touchEvent->touchPointes[touchEvent->touchPointSize-1].pressure;
765        }
766        default:
767            break;
768    }
769    return 0.0f;
770}
771
772float OH_ArkUI_PointerEvent_GetTiltX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
773{
774    if (!event) {
775        return 0.0f;
776    }
777    switch (event->eventTypeId) {
778        case C_TOUCH_EVENT_ID: {
779            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
780            if (!touchEvent || touchEvent->touchPointSize <= 0) {
781                return 0.0f;
782            }
783            return touchEvent->touchPointes[touchEvent->touchPointSize-1].tiltX;
784        }
785        default:
786            break;
787    }
788    return 0.0f;
789}
790
791float OH_ArkUI_PointerEvent_GetTiltY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
792{
793    if (!event) {
794        return 0.0f;
795    }
796    switch (event->eventTypeId) {
797        case C_TOUCH_EVENT_ID: {
798            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
799            if (!touchEvent || touchEvent->touchPointSize <= 0) {
800                return 0.0f;
801            }
802            return touchEvent->touchPointes[touchEvent->touchPointSize-1].tiltY;
803        }
804        default:
805            break;
806    }
807    return 0.0f;
808}
809
810float OH_ArkUI_PointerEvent_GetTouchAreaWidth(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
811{
812    if (!event) {
813        return 0.0f;
814    }
815    switch (event->eventTypeId) {
816        case C_TOUCH_EVENT_ID: {
817            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
818            if (!touchEvent || touchEvent->touchPointSize <= 0) {
819                return 0.0f;
820            }
821            return touchEvent->touchPointes[touchEvent->touchPointSize-1].contactAreaWidth;
822        }
823        default:
824            break;
825    }
826    return 0.0f;
827}
828
829float OH_ArkUI_PointerEvent_GetTouchAreaHeight(const ArkUI_UIInputEvent* event, uint32_t pointerIndex)
830{
831    if (!event) {
832        return 0.0f;
833    }
834    switch (event->eventTypeId) {
835        case C_TOUCH_EVENT_ID: {
836            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
837            if (!touchEvent || touchEvent->touchPointSize <= 0) {
838                return 0.0f;
839            }
840            return touchEvent->touchPointes[touchEvent->touchPointSize-1].contactAreaHeight;
841        }
842        default:
843            break;
844    }
845    return 0.0f;
846}
847
848uint32_t OH_ArkUI_PointerEvent_GetHistorySize(const ArkUI_UIInputEvent* event)
849{
850    if (!event) {
851        return 0;
852    }
853    switch (event->eventTypeId) {
854        case C_TOUCH_EVENT_ID: {
855            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
856            if (!touchEvent || !touchEvent->historyEvents) {
857                return 0;
858            }
859            return touchEvent->historySize;
860        }
861        default:
862            break;
863    }
864    return 0;
865}
866
867int64_t OH_ArkUI_PointerEvent_GetHistoryEventTime(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
868{
869    if (!event) {
870        return 0;
871    }
872    switch (event->eventTypeId) {
873        case C_TOUCH_EVENT_ID: {
874            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
875            if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
876                historyIndex < 0) {
877                return 0;
878            }
879            return touchEvent->historyEvents[historyIndex].timeStamp;
880        }
881        default:
882            break;
883    }
884    return 0;
885}
886
887uint32_t OH_ArkUI_PointerEvent_GetHistoryPointerCount(const ArkUI_UIInputEvent* event, uint32_t historyIndex)
888{
889    if (!event) {
890        return 0;
891    }
892    switch (event->eventTypeId) {
893        case C_TOUCH_EVENT_ID: {
894            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
895            if (!touchEvent || !touchEvent->historyEvents || touchEvent->historySize <= historyIndex ||
896                historyIndex < 0) {
897                return 0;
898            }
899            return touchEvent->historyEvents[historyIndex].touchPointSize;
900        }
901        default:
902            break;
903    }
904    return 0;
905}
906
907int32_t OH_ArkUI_PointerEvent_GetHistoryPointerId(
908    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
909{
910    if (!event) {
911        return 0;
912    }
913    switch (event->eventTypeId) {
914        case C_TOUCH_EVENT_ID: {
915            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
916            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
917                return 0;
918            }
919            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].id;
920        }
921        default:
922            break;
923    }
924    return 0;
925}
926
927float OH_ArkUI_PointerEvent_GetHistoryX(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
928{
929    if (!event) {
930        return 0.0f;
931    }
932    switch (event->eventTypeId) {
933        case C_TOUCH_EVENT_ID: {
934            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
935            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
936                return 0.0f;
937            }
938            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeX;
939        }
940        default:
941            break;
942    }
943    return 0.0f;
944}
945
946float OH_ArkUI_PointerEvent_GetHistoryY(const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
947{
948    if (!event) {
949        return 0.0f;
950    }
951    switch (event->eventTypeId) {
952        case C_TOUCH_EVENT_ID: {
953            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
954            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
955                return 0.0f;
956            }
957            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].nodeY;
958        }
959        default:
960            break;
961    }
962    return 0.0f;
963}
964
965float OH_ArkUI_PointerEvent_GetHistoryWindowX(
966    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
967{
968    if (!event) {
969        return 0.0f;
970    }
971    switch (event->eventTypeId) {
972        case C_TOUCH_EVENT_ID: {
973            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
974            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
975                return 0.0f;
976            }
977            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowX;
978        }
979        default:
980            break;
981    }
982    return 0.0f;
983}
984
985float OH_ArkUI_PointerEvent_GetHistoryWindowY(
986    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
987{
988    if (!event) {
989        return 0.0f;
990    }
991    switch (event->eventTypeId) {
992        case C_TOUCH_EVENT_ID: {
993            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
994            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
995                return 0.0f;
996            }
997            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].windowY;
998        }
999        default:
1000            break;
1001    }
1002    return 0.0f;
1003}
1004
1005float OH_ArkUI_PointerEvent_GetHistoryDisplayX(
1006    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1007{
1008    if (!event) {
1009        return 0.0f;
1010    }
1011    switch (event->eventTypeId) {
1012        case C_TOUCH_EVENT_ID: {
1013            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1014            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1015                return 0.0f;
1016            }
1017            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenX;
1018        }
1019        default:
1020            break;
1021    }
1022    return 0.0f;
1023}
1024
1025float OH_ArkUI_PointerEvent_GetHistoryDisplayY(
1026    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1027{
1028    if (!event) {
1029        return 0.0f;
1030    }
1031    switch (event->eventTypeId) {
1032        case C_TOUCH_EVENT_ID: {
1033            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1034            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1035                return 0.0f;
1036            }
1037            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].screenY;
1038        }
1039        default:
1040            break;
1041    }
1042    return 0.0f;
1043}
1044
1045float OH_ArkUI_PointerEvent_GetHistoryPressure(
1046    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1047{
1048    if (!event) {
1049        return 0.0f;
1050    }
1051    switch (event->eventTypeId) {
1052        case C_TOUCH_EVENT_ID: {
1053            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1054            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1055                return 0.0f;
1056            }
1057            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].pressure;
1058        }
1059        default:
1060            break;
1061    }
1062    return 0.0f;
1063}
1064
1065float OH_ArkUI_PointerEvent_GetHistoryTiltX(
1066    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1067{
1068    if (!event) {
1069        return 0.0f;
1070    }
1071    switch (event->eventTypeId) {
1072        case C_TOUCH_EVENT_ID: {
1073            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1074            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1075                return 0.0f;
1076            }
1077            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltX;
1078        }
1079        default:
1080            break;
1081    }
1082    return 0.0f;
1083}
1084
1085float OH_ArkUI_PointerEvent_GetHistoryTiltY(
1086    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1087{
1088    if (!event) {
1089        return 0.0f;
1090    }
1091    switch (event->eventTypeId) {
1092        case C_TOUCH_EVENT_ID: {
1093            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1094            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1095                return 0.0f;
1096            }
1097            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].tiltY;
1098        }
1099        default:
1100            break;
1101    }
1102    return 0.0f;
1103}
1104
1105float OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(
1106    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1107{
1108    if (!event) {
1109        return 0.0f;
1110    }
1111    switch (event->eventTypeId) {
1112        case C_TOUCH_EVENT_ID: {
1113            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1114            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1115                return 0.0f;
1116            }
1117            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaWidth;
1118        }
1119        default:
1120            break;
1121    }
1122    return 0.0f;
1123}
1124
1125float OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(
1126    const ArkUI_UIInputEvent* event, uint32_t pointerIndex, uint32_t historyIndex)
1127{
1128    if (!event) {
1129        return 0.0f;
1130    }
1131    switch (event->eventTypeId) {
1132        case C_TOUCH_EVENT_ID: {
1133            const auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1134            if (!isHistoryCTouchEventParamValid(touchEvent, historyIndex, pointerIndex)) {
1135                return 0.0f;
1136            }
1137            return touchEvent->historyEvents[historyIndex].touchPointes[pointerIndex].contactAreaHeight;
1138        }
1139        default:
1140            break;
1141    }
1142    return 0.0f;
1143}
1144
1145double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
1146{
1147    if (!event) {
1148        return 0.0;
1149    }
1150    switch (event->eventTypeId) {
1151        case AXIS_EVENT_ID: {
1152            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1153            if (axisEvent) {
1154                return axisEvent->verticalAxis;
1155            }
1156            break;
1157        }
1158        case C_AXIS_EVENT_ID: {
1159            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1160            if (!axisEvent) {
1161                return 0.0;
1162            }
1163            return axisEvent->verticalAxis;
1164        }
1165        default:
1166            break;
1167    }
1168    return 0.0;
1169}
1170
1171double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)
1172{
1173    if (!event) {
1174        return 0.0;
1175    }
1176    switch (event->eventTypeId) {
1177        case AXIS_EVENT_ID: {
1178            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1179            if (axisEvent) {
1180                return axisEvent->horizontalAxis;
1181            }
1182            break;
1183        }
1184        case C_AXIS_EVENT_ID: {
1185            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1186            if (!axisEvent) {
1187                return 0.0;
1188            }
1189            return axisEvent->horizontalAxis;
1190        }
1191        default:
1192            break;
1193    }
1194    return 0.0;
1195}
1196
1197double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)
1198{
1199    if (!event) {
1200        return 0.0;
1201    }
1202    switch (event->eventTypeId) {
1203        case AXIS_EVENT_ID: {
1204            const auto* axisEvent = reinterpret_cast<const OHOS::Ace::AxisEvent*>(event->inputEvent);
1205            if (axisEvent) {
1206                return axisEvent->pinchAxisScale;
1207            }
1208            break;
1209        }
1210        case C_AXIS_EVENT_ID: {
1211            const auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(event->inputEvent);
1212            if (!axisEvent) {
1213                return 0.0;
1214            }
1215            return axisEvent->pinchAxisScale;
1216        }
1217        default:
1218            break;
1219    }
1220    return 0.0;
1221}
1222
1223int32_t OH_ArkUI_PointerEvent_SetInterceptHitTestMode(const ArkUI_UIInputEvent* event, HitTestMode mode)
1224{
1225    if (!event) {
1226        return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1227    }
1228    switch (event->eventTypeId) {
1229        case C_TOUCH_EVENT_ID: {
1230            auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1231            touchEvent->interceptResult = static_cast<int32_t>(mode);
1232            break;
1233        }
1234        case C_MOUSE_EVENT_ID: {
1235            auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1236            if (!mouseEvent) {
1237                return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1238            }
1239            return mouseEvent->interceptResult = static_cast<int32_t>(mode);
1240        }
1241        default:
1242            return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1243    }
1244    return OHOS::Ace::ERROR_CODE_NO_ERROR;
1245}
1246
1247int32_t OH_ArkUI_PointerEvent_SetStopPropagation(const ArkUI_UIInputEvent* event, bool stopPropagation)
1248{
1249    if (!event) {
1250        return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1251    }
1252    switch (event->eventTypeId) {
1253        case C_TOUCH_EVENT_ID: {
1254            auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(event->inputEvent);
1255            touchEvent->stopPropagation = stopPropagation;
1256            break;
1257        }
1258        default:
1259            return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
1260    }
1261    return OHOS::Ace::ERROR_CODE_NO_ERROR;
1262}
1263
1264int32_t OH_ArkUI_MouseEvent_GetMouseButton(const ArkUI_UIInputEvent* event)
1265{
1266    if (!event) {
1267        return -1;
1268    }
1269    switch (event->eventTypeId) {
1270        case C_MOUSE_EVENT_ID: {
1271            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1272            if (!mouseEvent) {
1273                return -1;
1274            }
1275            return OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(mouseEvent->button);
1276        }
1277        default:
1278            break;
1279    }
1280    return -1;
1281}
1282
1283int32_t OH_ArkUI_MouseEvent_GetMouseAction(const ArkUI_UIInputEvent* event)
1284{
1285    if (!event) {
1286        return -1;
1287    }
1288    switch (event->eventTypeId) {
1289        case C_MOUSE_EVENT_ID: {
1290            const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(event->inputEvent);
1291            if (!mouseEvent) {
1292                return -1;
1293            }
1294            return OHOS::Ace::NodeModel::ConvertToCMouseActionType(mouseEvent->action);
1295        }
1296        default:
1297            break;
1298    }
1299    return -1;
1300}
1301
1302#ifdef __cplusplus
1303};
1304#endif
1305