input.cpp revision c5ed5910c9ef066cec6a13bbb404ec57b1e92637 
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
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#define LOG_TAG "input"
18#include <utils/Log.h>
19
20#include <android/input.h>
21#include <ui/Input.h>
22#include <ui/InputTransport.h>
23#include <utils/PollLoop.h>
24
25#include <android_runtime/android_app_NativeActivity.h>
26
27#include <poll.h>
28
29using android::InputEvent;
30using android::KeyEvent;
31using android::MotionEvent;
32
33int32_t AInputEvent_getType(const AInputEvent* event) {
34    return static_cast<const InputEvent*>(event)->getType();
35}
36
37int32_t AInputEvent_getDeviceId(const AInputEvent* event) {
38    return static_cast<const InputEvent*>(event)->getDeviceId();
39}
40
41int32_t AInputEvent_getSource(const AInputEvent* event) {
42    return static_cast<const InputEvent*>(event)->getSource();
43}
44
45int32_t AKeyEvent_getAction(const AInputEvent* key_event) {
46    return static_cast<const KeyEvent*>(key_event)->getAction();
47}
48
49int32_t AKeyEvent_getFlags(const AInputEvent* key_event) {
50    return static_cast<const KeyEvent*>(key_event)->getFlags();
51}
52
53int32_t AKeyEvent_getKeyCode(const AInputEvent* key_event) {
54    return static_cast<const KeyEvent*>(key_event)->getKeyCode();
55}
56
57int32_t AKeyEvent_getScanCode(const AInputEvent* key_event) {
58    return static_cast<const KeyEvent*>(key_event)->getScanCode();
59}
60
61int32_t AKeyEvent_getMetaState(const AInputEvent* key_event) {
62    return static_cast<const KeyEvent*>(key_event)->getMetaState();
63}
64int32_t AKeyEvent_getRepeatCount(const AInputEvent* key_event) {
65    return static_cast<const KeyEvent*>(key_event)->getRepeatCount();
66}
67
68int64_t AKeyEvent_getDownTime(const AInputEvent* key_event) {
69    return static_cast<const KeyEvent*>(key_event)->getDownTime();
70}
71
72
73int64_t AKeyEvent_getEventTime(const AInputEvent* key_event) {
74    return static_cast<const KeyEvent*>(key_event)->getEventTime();
75}
76
77int32_t AMotionEvent_getAction(const AInputEvent* motion_event) {
78    return static_cast<const MotionEvent*>(motion_event)->getAction();
79}
80
81int32_t AMotionEvent_getMetaState(const AInputEvent* motion_event) {
82    return static_cast<const MotionEvent*>(motion_event)->getMetaState();
83}
84
85int32_t AMotionEvent_getEdgeFlags(const AInputEvent* motion_event) {
86    return reinterpret_cast<const MotionEvent*>(motion_event)->getEdgeFlags();
87}
88
89int64_t AMotionEvent_getDownTime(const AInputEvent* motion_event) {
90    return static_cast<const MotionEvent*>(motion_event)->getDownTime();
91}
92
93int64_t AMotionEvent_getEventTime(const AInputEvent* motion_event) {
94    return static_cast<const MotionEvent*>(motion_event)->getEventTime();
95}
96
97float AMotionEvent_getXOffset(const AInputEvent* motion_event) {
98    return static_cast<const MotionEvent*>(motion_event)->getXOffset();
99}
100
101float AMotionEvent_getYOffset(const AInputEvent* motion_event) {
102    return static_cast<const MotionEvent*>(motion_event)->getYOffset();
103}
104
105float AMotionEvent_getXPrecision(const AInputEvent* motion_event) {
106    return static_cast<const MotionEvent*>(motion_event)->getXPrecision();
107}
108
109float AMotionEvent_getYPrecision(const AInputEvent* motion_event) {
110    return static_cast<const MotionEvent*>(motion_event)->getYPrecision();
111}
112
113size_t AMotionEvent_getPointerCount(const AInputEvent* motion_event) {
114    return static_cast<const MotionEvent*>(motion_event)->getPointerCount();
115}
116
117int32_t AMotionEvent_getPointerId(const AInputEvent* motion_event, size_t pointer_index) {
118    return static_cast<const MotionEvent*>(motion_event)->getPointerId(pointer_index);
119}
120
121float AMotionEvent_getRawX(const AInputEvent* motion_event, size_t pointer_index) {
122    return static_cast<const MotionEvent*>(motion_event)->getRawX(pointer_index);
123}
124
125float AMotionEvent_getRawY(const AInputEvent* motion_event, size_t pointer_index) {
126    return static_cast<const MotionEvent*>(motion_event)->getRawY(pointer_index);
127}
128
129float AMotionEvent_getX(const AInputEvent* motion_event, size_t pointer_index) {
130    return static_cast<const MotionEvent*>(motion_event)->getX(pointer_index);
131}
132
133float AMotionEvent_getY(const AInputEvent* motion_event, size_t pointer_index) {
134    return static_cast<const MotionEvent*>(motion_event)->getY(pointer_index);
135}
136
137float AMotionEvent_getPressure(const AInputEvent* motion_event, size_t pointer_index) {
138    return static_cast<const MotionEvent*>(motion_event)->getPressure(pointer_index);
139}
140
141float AMotionEvent_getSize(const AInputEvent* motion_event, size_t pointer_index) {
142    return static_cast<const MotionEvent*>(motion_event)->getSize(pointer_index);
143}
144
145float AMotionEvent_getTouchMajor(const AInputEvent* motion_event, size_t pointer_index) {
146    return static_cast<const MotionEvent*>(motion_event)->getTouchMajor(pointer_index);
147}
148
149float AMotionEvent_getTouchMinor(const AInputEvent* motion_event, size_t pointer_index) {
150    return static_cast<const MotionEvent*>(motion_event)->getTouchMinor(pointer_index);
151}
152
153float AMotionEvent_getToolMajor(const AInputEvent* motion_event, size_t pointer_index) {
154    return static_cast<const MotionEvent*>(motion_event)->getToolMajor(pointer_index);
155}
156
157float AMotionEvent_getToolMinor(const AInputEvent* motion_event, size_t pointer_index) {
158    return static_cast<const MotionEvent*>(motion_event)->getToolMinor(pointer_index);
159}
160
161float AMotionEvent_getOrientation(const AInputEvent* motion_event, size_t pointer_index) {
162    return static_cast<const MotionEvent*>(motion_event)->getOrientation(pointer_index);
163}
164
165size_t AMotionEvent_getHistorySize(const AInputEvent* motion_event) {
166    return static_cast<const MotionEvent*>(motion_event)->getHistorySize();
167}
168
169int64_t AMotionEvent_getHistoricalEventTime(AInputEvent* motion_event,
170        size_t history_index) {
171    return static_cast<const MotionEvent*>(motion_event)->getHistoricalEventTime(
172            history_index);
173}
174
175float AMotionEvent_getHistoricalRawX(AInputEvent* motion_event, size_t pointer_index,
176        size_t history_index) {
177    return static_cast<const MotionEvent*>(motion_event)->getHistoricalRawX(
178            pointer_index, history_index);
179}
180
181float AMotionEvent_getHistoricalRawY(AInputEvent* motion_event, size_t pointer_index,
182        size_t history_index) {
183    return static_cast<const MotionEvent*>(motion_event)->getHistoricalRawY(
184            pointer_index, history_index);
185}
186
187float AMotionEvent_getHistoricalX(AInputEvent* motion_event, size_t pointer_index,
188        size_t history_index) {
189    return static_cast<const MotionEvent*>(motion_event)->getHistoricalX(
190            pointer_index, history_index);
191}
192
193float AMotionEvent_getHistoricalY(AInputEvent* motion_event, size_t pointer_index,
194        size_t history_index) {
195    return static_cast<const MotionEvent*>(motion_event)->getHistoricalY(
196            pointer_index, history_index);
197}
198
199float AMotionEvent_getHistoricalPressure(AInputEvent* motion_event, size_t pointer_index,
200        size_t history_index) {
201    return static_cast<const MotionEvent*>(motion_event)->getHistoricalPressure(
202            pointer_index, history_index);
203}
204
205float AMotionEvent_getHistoricalSize(AInputEvent* motion_event, size_t pointer_index,
206        size_t history_index) {
207    return static_cast<const MotionEvent*>(motion_event)->getHistoricalSize(
208            pointer_index, history_index);
209}
210
211float AMotionEvent_getHistoricalTouchMajor(AInputEvent* motion_event, size_t pointer_index,
212        size_t history_index) {
213    return static_cast<const MotionEvent*>(motion_event)->getHistoricalTouchMajor(
214            pointer_index, history_index);
215}
216
217float AMotionEvent_getHistoricalTouchMinor(AInputEvent* motion_event, size_t pointer_index,
218        size_t history_index) {
219    return static_cast<const MotionEvent*>(motion_event)->getHistoricalTouchMinor(
220            pointer_index, history_index);
221}
222
223float AMotionEvent_getHistoricalToolMajor(AInputEvent* motion_event, size_t pointer_index,
224        size_t history_index) {
225    return static_cast<const MotionEvent*>(motion_event)->getHistoricalToolMajor(
226            pointer_index, history_index);
227}
228
229float AMotionEvent_getHistoricalToolMinor(AInputEvent* motion_event, size_t pointer_index,
230        size_t history_index) {
231    return static_cast<const MotionEvent*>(motion_event)->getHistoricalToolMinor(
232            pointer_index, history_index);
233}
234
235float AMotionEvent_getHistoricalOrientation(AInputEvent* motion_event, size_t pointer_index,
236        size_t history_index) {
237    return static_cast<const MotionEvent*>(motion_event)->getHistoricalOrientation(
238            pointer_index, history_index);
239}
240
241
242void AInputQueue_attachLooper(AInputQueue* queue, ALooper* looper,
243        ALooper_callbackFunc* callback, void* data) {
244    queue->attachLooper(looper, callback, data);
245}
246
247void AInputQueue_detachLooper(AInputQueue* queue) {
248    queue->detachLooper();
249}
250
251int AInputQueue_hasEvents(AInputQueue* queue) {
252    return queue->hasEvents();
253}
254
255int32_t AInputQueue_getEvent(AInputQueue* queue, AInputEvent** outEvent) {
256    return queue->getEvent(outEvent);
257}
258
259void AInputQueue_finishEvent(AInputQueue* queue, AInputEvent* event, int handled) {
260    queue->finishEvent(event, handled != 0);
261}
262