1/*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License")
4{}
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "libinput_interface.h"
18
19namespace {
20OHOS::MMI::LibinputInterface *g_instance = nullptr;
21} // namespace
22
23namespace OHOS {
24namespace MMI {
25
26LibinputInterface::LibinputInterface()
27{
28    g_instance = this;
29}
30} // namespace MMI
31} // namespace OHOS
32
33extern "C" {
34enum libinput_event_type libinput_event_get_type(struct libinput_event *event)
35{
36    return g_instance->GetEventType(event);
37}
38
39enum libinput_tablet_tool_tip_state libinput_event_tablet_tool_get_tip_state(struct libinput_event_tablet_tool *event)
40{
41    return g_instance->TabletToolGetTipState(event);
42}
43
44double libinput_event_tablet_tool_get_tilt_x(struct libinput_event_tablet_tool *event)
45{
46    return g_instance->TabletToolGetTiltX(event);
47}
48
49enum libinput_pointer_axis_source libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
50{
51    return g_instance->GetAxisSource(event);
52}
53
54double libinput_event_tablet_tool_get_tilt_y(struct libinput_event_tablet_tool *event)
55{
56    return g_instance->TabletToolGetTiltY(event);
57}
58
59uint64_t libinput_event_tablet_tool_get_time_usec(struct libinput_event_tablet_tool *event)
60{
61    return g_instance->TabletToolGetTimeUsec(event);
62}
63
64double libinput_event_tablet_tool_get_pressure(struct libinput_event_tablet_tool *event)
65{
66    return g_instance->TabletToolGetPressure(event);
67}
68
69int32_t libinput_event_tablet_tool_get_tool_type(struct libinput_event_tablet_tool *event)
70{
71    return g_instance->TabletToolGetToolType(event);
72}
73
74enum libinput_tablet_tool_type libinput_tablet_tool_get_type(struct libinput_tablet_tool *tool)
75{
76    return g_instance->TabletToolGetType(tool);
77}
78
79struct libinput_tablet_tool* libinput_event_tablet_tool_get_tool(struct libinput_event_tablet_tool *event)
80{
81    return g_instance->TabletToolGetTool(event);
82}
83
84struct libinput_device* libinput_event_get_device(struct libinput_event *event)
85{
86    return g_instance->GetDevice(event);
87}
88
89uint64_t libinput_event_get_sensortime(struct libinput_event *event)
90{
91    return g_instance->GetSensorTime(event);
92}
93
94struct libinput_event_keyboard* libinput_event_get_keyboard_event(struct libinput_event *event)
95{
96    return g_instance->LibinputEventGetKeyboardEvent(event);
97}
98
99struct libinput_event_pointer* libinput_event_get_pointer_event(struct libinput_event *event)
100{
101    return g_instance->LibinputGetPointerEvent(event);
102}
103
104struct libinput_event_touch* libinput_event_get_touch_event(struct libinput_event *event)
105{
106    return g_instance->GetTouchEvent(event);
107}
108
109struct libinput_event_touch* libinput_event_get_touchpad_event(struct libinput_event *event)
110{
111    return g_instance->GetTouchpadEvent(event);
112}
113
114struct libinput_event_gesture* libinput_event_get_gesture_event(struct libinput_event *event)
115{
116    return g_instance->GetGestureEvent(event);
117}
118
119struct libinput_event_tablet_tool* libinput_event_get_tablet_tool_event(struct libinput_event *event)
120{
121    return g_instance->GetTabletToolEvent(event);
122}
123
124uint64_t libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event)
125{
126    return (event != nullptr ? event->base.time : 0);
127}
128
129uint32_t libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
130{
131    return g_instance->LibinputEventKeyboardGetKey(event);
132}
133
134int libinput_device_keyboard_has_key(struct libinput_device *device, uint32_t code)
135{
136    return 0;
137}
138
139enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
140{
141    return g_instance->LibinputEventKeyboardGetKeyState(event);
142}
143
144enum libinput_button_state libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
145{
146    return (event != nullptr ? event->buttonState : LIBINPUT_BUTTON_STATE_RELEASED);
147}
148
149uint64_t libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
150{
151    return g_instance->TouchEventGetTime(event);
152}
153
154int32_t libinput_event_touch_get_seat_slot(struct libinput_event_touch *event)
155{
156    return g_instance->TouchEventGetSeatSlot(event);
157}
158
159double libinput_event_touch_get_pressure(struct libinput_event_touch* event)
160{
161    return g_instance->TouchEventGetPressure(event);
162}
163
164int32_t libinput_event_touch_get_move_flag(struct libinput_event_touch* event)
165{
166    return g_instance->TouchEventGetMoveFlag(event);
167}
168
169int32_t libinput_event_get_touch_contact_long_axis(struct libinput_event_touch *event)
170{
171    return g_instance->TouchEventGetContactLongAxis(event);
172}
173
174int32_t libinput_event_get_touch_contact_short_axis(struct libinput_event_touch *event)
175{
176    return g_instance->TouchEventGetContactShortAxis(event);
177}
178
179int32_t libinput_event_touch_get_tool_type(struct libinput_event_touch *event)
180{
181    return g_instance->TouchEventGetToolType(event);
182}
183
184int libinput_device_touch_btn_tool_type_down(struct libinput_device *device, int32_t btnToolType)
185{
186    return g_instance->TouchEventGetBtnToolTypeDown(device, btnToolType);
187}
188
189double libinput_event_touch_get_x_transformed(struct libinput_event_touch *event, uint32_t width)
190{
191    return -1.0;
192}
193
194double libinput_event_touch_get_y_transformed(struct libinput_event_touch *event, uint32_t height)
195{
196    return -1.0;
197}
198
199double libinput_event_touch_get_tool_x_transformed(struct libinput_event_touch *event, uint32_t width)
200{
201    return -1.0;
202}
203
204double libinput_event_touch_get_tool_y_transformed(struct libinput_event_touch *event, uint32_t height)
205{
206    return -1.0;
207}
208
209double libinput_event_touch_get_tool_width_transformed(struct libinput_event_touch *event, uint32_t width)
210{
211    return -1.0;
212}
213
214double libinput_event_touch_get_tool_height_transformed(struct libinput_event_touch *event, uint32_t height)
215{
216    return -1.0;
217}
218
219double libinput_event_tablet_tool_get_x_transformed(struct libinput_event_tablet_tool *event, uint32_t width)
220{
221    return -1.0;
222}
223
224double libinput_event_tablet_tool_get_y_transformed(struct libinput_event_tablet_tool *event, uint32_t height)
225{
226    return -1.0;
227}
228
229uint64_t libinput_event_touchpad_get_time_usec(struct libinput_event_touch *event)
230{
231    return (event != nullptr ? event->base.time : 0);
232}
233
234int32_t libinput_event_touchpad_get_seat_slot(struct libinput_event_touch *event)
235{
236    return (event != nullptr ? event->seatSlot : 0);
237}
238
239double libinput_event_touchpad_get_x(struct libinput_event_touch *event)
240{
241    return (event != nullptr ? event->x : 0.0);
242}
243
244double libinput_event_touchpad_get_y(struct libinput_event_touch *event)
245{
246    return (event != nullptr ? event->y : 0.0);
247}
248
249double libinput_event_touchpad_get_pressure(struct libinput_event_touch *event)
250{
251    return (event != nullptr ? event->pressure : 0.0);
252}
253
254int32_t libinput_event_touchpad_get_touch_contact_long_axis(struct libinput_event_touch *event)
255{
256    return (event != nullptr ? event->longAxis : 0);
257}
258
259int32_t libinput_event_touchpad_get_touch_contact_short_axis(struct libinput_event_touch *event)
260{
261    return (event != nullptr ? event->shortAxis : 0);
262}
263
264int32_t libinput_event_touchpad_get_tool_type(struct libinput_event_touch *event)
265{
266    return g_instance->TouchpadGetTool(event);
267}
268
269int32_t libinput_device_touchpad_btn_tool_type_down(struct libinput_device *device, int32_t btnToolType)
270{
271    return -1;
272}
273
274double libinput_event_touchpad_get_tool_x(struct libinput_event_touch *event)
275{
276    return (event != nullptr ? event->toolX : 0.0);
277}
278
279double libinput_event_touchpad_get_tool_y(struct libinput_event_touch *event)
280{
281    return (event != nullptr ? event->toolY : 0.0);
282}
283
284double libinput_event_touchpad_get_tool_width(struct libinput_event_touch *event)
285{
286    return (event != nullptr ? event->toolWidth : 0.0);
287}
288
289double libinput_event_touchpad_get_tool_height(struct libinput_event_touch *event)
290{
291    return (event != nullptr ? event->toolWidth : 0.0);
292}
293
294uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event)
295{
296    return g_instance->GestureEventGetTime(event);
297}
298
299int libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event)
300{
301    return g_instance->GestureEventGetFingerCount(event);
302}
303
304double libinput_event_gesture_get_scale(struct libinput_event_gesture *event)
305{
306    return (event != nullptr ? static_cast<double>(event->scale) : 1.0);
307}
308
309double libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event)
310{
311    return (event != nullptr ? static_cast<double>(event->angle) : 0.0);
312}
313
314int libinput_event_gesture_get_device_coords_x(struct libinput_event_gesture *event, uint32_t idx)
315{
316    return g_instance->GestureEventGetDevCoordsX(event, idx);
317}
318
319int libinput_event_gesture_get_device_coords_y(struct libinput_event_gesture *event, uint32_t idx)
320{
321    return g_instance->GestureEventGetDevCoordsY(event, idx);
322}
323
324int libinput_has_event_led_type(struct libinput_device *device)
325{
326    return 0;
327}
328
329const char* libinput_device_get_name(struct libinput_device *device)
330{
331    return g_instance->DeviceGetName(device);
332}
333
334unsigned int libinput_device_get_id_bustype(struct libinput_device *device)
335{
336    return (device != nullptr ? device->busType : 0);
337}
338
339unsigned int libinput_device_get_id_version(struct libinput_device *device)
340{
341    return (device != nullptr ? device->version : 0);
342}
343
344unsigned int libinput_device_get_id_product(struct libinput_device *device)
345{
346    return (device != nullptr ? device->product : 0);
347}
348
349unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
350{
351    return (device != nullptr ? device->vendor : 0);
352}
353
354const char* libinput_device_get_phys(struct libinput_device* device)
355{
356    return "";
357}
358
359const char* libinput_device_get_uniq(struct libinput_device* device)
360{
361    return "";
362}
363
364const char* libinput_device_get_sysname(struct libinput_device *device)
365{
366    return nullptr;
367}
368
369struct udev_device* libinput_device_get_udev_device(struct libinput_device *device)
370{
371    return nullptr;
372}
373
374enum evdev_device_udev_tags libinput_device_get_tags(struct libinput_device* device)
375{
376    return EVDEV_UDEV_TAG_INPUT;
377}
378
379int libinput_device_has_capability(struct libinput_device *device, enum libinput_device_capability capability)
380{
381    return 0;
382}
383
384int32_t libinput_device_has_key(struct libinput_device* device, int32_t keyCode)
385{
386    return 0;
387}
388
389int32_t libinput_device_get_axis_min(struct libinput_device* device, int32_t code)
390{
391    return -1;
392}
393
394int32_t libinput_device_get_axis_max(struct libinput_device* device, int32_t code)
395{
396    return -1;
397}
398
399int32_t libinput_device_get_axis_fuzz(struct libinput_device* device, int32_t code)
400{
401    return -1;
402}
403
404int32_t libinput_device_get_axis_flat(struct libinput_device* device, int32_t code)
405{
406    return -1;
407}
408
409int32_t libinput_device_get_axis_resolution(struct libinput_device* device, int32_t code)
410{
411    return -1;
412}
413
414int libinput_get_funckey_state(struct libinput_device *device, unsigned int code)
415{
416    return 0;
417}
418
419uint32_t libinput_event_pointer_get_finger_count(struct libinput_event_pointer *event)
420{
421    return g_instance->PointerEventGetFingerCount(event);
422}
423
424double libinput_event_pointer_get_dx_unaccelerated(struct libinput_event_pointer *event)
425{
426    return g_instance->PointerGetDxUnaccelerated(event);
427}
428
429double libinput_event_pointer_get_dy_unaccelerated(struct libinput_event_pointer *event)
430{
431    return g_instance->PointerGetDyUnaccelerated(event);
432}
433
434uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
435{
436    return g_instance->PointerGetButton(event);
437}
438
439int libinput_event_pointer_has_axis(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
440{
441    return g_instance->PointerHasAxis(event, axis);
442}
443
444double libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
445{
446    return g_instance->PointerGetAxisValue(event, axis);
447}
448} // extern "C"
449