blob: 2c91fab90357e22ebc4c461b1228dab399a91b48 [file] [log] [blame]
Jeff Brown46b9ac0a2010-04-22 18:58:52 -07001/*
2 * Copyright (C) 2010 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
Mathias Agopianb93a03f82012-02-17 15:34:57 -080017#ifndef _ANDROIDFW_INPUT_H
18#define _ANDROIDFW_INPUT_H
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070019
20/**
21 * Native input event structures.
22 */
23
24#include <android/input.h>
25#include <utils/Vector.h>
Jeff Brown6d0fec22010-07-23 21:28:06 -070026#include <utils/KeyedVector.h>
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070027#include <utils/Timers.h>
Jeff Brown6d0fec22010-07-23 21:28:06 -070028#include <utils/RefBase.h>
29#include <utils/String8.h>
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070030
Jeff Brown91c69ab2011-02-14 17:03:18 -080031#ifdef HAVE_ANDROID_OS
32class SkMatrix;
33#endif
34
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070035/*
36 * Additional private constants not defined in ndk/ui/input.h.
37 */
38enum {
Jeff Brown21bc5c92011-02-28 18:27:14 -080039 /* Private control to determine when an app is tracking a key sequence. */
40 AKEY_EVENT_FLAG_START_TRACKING = 0x40000000,
41
42 /* Key event is inconsistent with previously sent key events. */
43 AKEY_EVENT_FLAG_TAINTED = 0x80000000,
44};
45
46enum {
47 /* Motion event is inconsistent with previously sent motion events. */
48 AMOTION_EVENT_FLAG_TAINTED = 0x80000000,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070049};
50
Jeff Brown89de57a2011-01-19 18:41:38 -080051enum {
52 /*
53 * Indicates that an input device has switches.
54 * This input source flag is hidden from the API because switches are only used by the system
55 * and applications have no way to interact with them.
56 */
57 AINPUT_SOURCE_SWITCH = 0x80000000,
58};
59
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070060/*
Jeff Brown05dc66a2011-03-02 14:41:58 -080061 * SystemUiVisibility constants from View.
62 */
63enum {
64 ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE = 0,
65 ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN = 0x00000001,
66};
67
68/*
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070069 * Maximum number of pointers supported per motion event.
Jeff Brown01ce2e92010-09-26 22:20:12 -070070 * Smallest number of pointers is 1.
Jeff Brown58a2da82011-01-25 16:02:22 -080071 * (We want at least 10 but some touch controllers obstensibly configured for 10 pointers
72 * will occasionally emit 11. There is not much harm making this constant bigger.)
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070073 */
Jeff Brown58a2da82011-01-25 16:02:22 -080074#define MAX_POINTERS 16
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070075
Dianne Hackborna95e4cb2010-06-18 18:09:33 -070076/*
Jeff Brown01ce2e92010-09-26 22:20:12 -070077 * Maximum pointer id value supported in a motion event.
78 * Smallest pointer id is 0.
79 * (This is limited by our use of BitSet32 to track pointer assignments.)
80 */
81#define MAX_POINTER_ID 31
82
83/*
Dianne Hackborna95e4cb2010-06-18 18:09:33 -070084 * Declare a concrete type for the NDK's input event forward declaration.
85 */
Dianne Hackbornd76b67c2010-07-13 17:48:30 -070086struct AInputEvent {
87 virtual ~AInputEvent() { }
88};
Dianne Hackborna95e4cb2010-06-18 18:09:33 -070089
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070090/*
Jeff Brown6d0fec22010-07-23 21:28:06 -070091 * Declare a concrete type for the NDK's input device forward declaration.
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070092 */
Jeff Brown6d0fec22010-07-23 21:28:06 -070093struct AInputDevice {
94 virtual ~AInputDevice() { }
Jeff Brown46b9ac0a2010-04-22 18:58:52 -070095};
96
Jeff Brown6d0fec22010-07-23 21:28:06 -070097
98namespace android {
99
Jeff Brown91c69ab2011-02-14 17:03:18 -0800100#ifdef HAVE_ANDROID_OS
101class Parcel;
102#endif
103
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700104/*
105 * Flags that flow alongside events in the input dispatch system to help with certain
106 * policy decisions such as waking from device sleep.
Jeff Brownb6997262010-10-08 22:31:17 -0700107 *
108 * These flags are also defined in frameworks/base/core/java/android/view/WindowManagerPolicy.java.
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700109 */
110enum {
Jeff Brown0eaf3932010-10-01 14:55:30 -0700111 /* These flags originate in RawEvents and are generally set in the key map.
Jeff Brown497a92c2010-09-12 17:55:08 -0700112 * NOTE: If you edit these flags, also edit labels in KeycodeLabels.h. */
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700113
114 POLICY_FLAG_WAKE = 0x00000001,
115 POLICY_FLAG_WAKE_DROPPED = 0x00000002,
116 POLICY_FLAG_SHIFT = 0x00000004,
117 POLICY_FLAG_CAPS_LOCK = 0x00000008,
118 POLICY_FLAG_ALT = 0x00000010,
119 POLICY_FLAG_ALT_GR = 0x00000020,
120 POLICY_FLAG_MENU = 0x00000040,
121 POLICY_FLAG_LAUNCHER = 0x00000080,
Jeff Brown0eaf3932010-10-01 14:55:30 -0700122 POLICY_FLAG_VIRTUAL = 0x00000100,
Jeff Brown497a92c2010-09-12 17:55:08 -0700123 POLICY_FLAG_FUNCTION = 0x00000200,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700124
Jeff Brown7fbdc842010-06-17 20:52:56 -0700125 POLICY_FLAG_RAW_MASK = 0x0000ffff,
126
Jeff Brown85a31762010-09-01 17:01:00 -0700127 /* These flags are set by the input dispatcher. */
128
129 // Indicates that the input event was injected.
130 POLICY_FLAG_INJECTED = 0x01000000,
131
Jeff Browne20c9e02010-10-11 14:20:19 -0700132 // Indicates that the input event is from a trusted source such as a directly attached
133 // input device or an application with system-wide event injection permission.
134 POLICY_FLAG_TRUSTED = 0x02000000,
135
Jeff Brown0029c662011-03-30 02:25:18 -0700136 // Indicates that the input event has passed through an input filter.
137 POLICY_FLAG_FILTERED = 0x04000000,
138
139 // Disables automatic key repeating behavior.
140 POLICY_FLAG_DISABLE_KEY_REPEAT = 0x08000000,
141
Jeff Brown9c3cda02010-06-15 01:31:58 -0700142 /* These flags are set by the input reader policy as it intercepts each event. */
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700143
144 // Indicates that the screen was off when the event was received and the event
145 // should wake the device.
146 POLICY_FLAG_WOKE_HERE = 0x10000000,
147
148 // Indicates that the screen was dim when the event was received and the event
149 // should brighten the device.
150 POLICY_FLAG_BRIGHT_HERE = 0x20000000,
Jeff Brownb6997262010-10-08 22:31:17 -0700151
152 // Indicates that the event should be dispatched to applications.
153 // The input event should still be sent to the InputDispatcher so that it can see all
154 // input events received include those that it will not deliver.
155 POLICY_FLAG_PASS_TO_USER = 0x40000000,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700156};
157
158/*
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700159 * Pointer coordinate data.
160 */
161struct PointerCoords {
Jeff Brown6f2fba42011-02-19 01:08:02 -0800162 enum { MAX_AXES = 14 }; // 14 so that sizeof(PointerCoords) == 64
Jeff Brown91c69ab2011-02-14 17:03:18 -0800163
164 // Bitfield of axes that are present in this structure.
Jeff Brown6f2fba42011-02-19 01:08:02 -0800165 uint64_t bits;
Jeff Brown91c69ab2011-02-14 17:03:18 -0800166
167 // Values of axes that are stored in this structure packed in order by axis id
168 // for each axis that is present in the structure according to 'bits'.
169 float values[MAX_AXES];
170
171 inline void clear() {
172 bits = 0;
173 }
174
Jeff Brown6f2fba42011-02-19 01:08:02 -0800175 float getAxisValue(int32_t axis) const;
176 status_t setAxisValue(int32_t axis, float value);
Jeff Brown91c69ab2011-02-14 17:03:18 -0800177
Dianne Hackborne2515ee2011-04-27 18:52:56 -0400178 void scale(float scale);
179
Jeff Brownbe1aa822011-07-27 16:04:54 -0700180 inline float getX() const {
181 return getAxisValue(AMOTION_EVENT_AXIS_X);
182 }
183
184 inline float getY() const {
185 return getAxisValue(AMOTION_EVENT_AXIS_Y);
186 }
187
Jeff Brown91c69ab2011-02-14 17:03:18 -0800188#ifdef HAVE_ANDROID_OS
189 status_t readFromParcel(Parcel* parcel);
190 status_t writeToParcel(Parcel* parcel) const;
191#endif
192
Jeff Brownace13b12011-03-09 17:39:48 -0800193 bool operator==(const PointerCoords& other) const;
194 inline bool operator!=(const PointerCoords& other) const {
195 return !(*this == other);
196 }
197
198 void copyFrom(const PointerCoords& other);
199
Jeff Brown91c69ab2011-02-14 17:03:18 -0800200private:
201 void tooManyAxes(int axis);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700202};
203
204/*
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700205 * Pointer property data.
206 */
207struct PointerProperties {
208 // The id of the pointer.
209 int32_t id;
210
211 // The pointer tool type.
212 int32_t toolType;
213
214 inline void clear() {
215 id = -1;
216 toolType = 0;
217 }
218
219 bool operator==(const PointerProperties& other) const;
220 inline bool operator!=(const PointerProperties& other) const {
221 return !(*this == other);
222 }
223
224 void copyFrom(const PointerProperties& other);
225};
226
227/*
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700228 * Input events.
229 */
Dianne Hackborn2e9f93e2010-06-28 15:27:30 -0700230class InputEvent : public AInputEvent {
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700231public:
232 virtual ~InputEvent() { }
233
234 virtual int32_t getType() const = 0;
235
236 inline int32_t getDeviceId() const { return mDeviceId; }
237
Jeff Brownc5ed5912010-07-14 18:48:53 -0700238 inline int32_t getSource() const { return mSource; }
Jeff Brown91c69ab2011-02-14 17:03:18 -0800239
240 inline void setSource(int32_t source) { mSource = source; }
241
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700242protected:
Jeff Brownc5ed5912010-07-14 18:48:53 -0700243 void initialize(int32_t deviceId, int32_t source);
Dianne Hackborn2c6081c2010-07-15 17:44:53 -0700244 void initialize(const InputEvent& from);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700245
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700246 int32_t mDeviceId;
Jeff Brownc5ed5912010-07-14 18:48:53 -0700247 int32_t mSource;
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700248};
249
Jeff Brown5c225b12010-06-16 01:53:36 -0700250/*
251 * Key events.
252 */
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700253class KeyEvent : public InputEvent {
254public:
255 virtual ~KeyEvent() { }
256
Jeff Brownc5ed5912010-07-14 18:48:53 -0700257 virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700258
259 inline int32_t getAction() const { return mAction; }
260
261 inline int32_t getFlags() const { return mFlags; }
262
Jeff Brownfd23e3e2012-05-09 13:34:28 -0700263 inline void setFlags(int32_t flags) { mFlags = flags; }
264
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700265 inline int32_t getKeyCode() const { return mKeyCode; }
266
267 inline int32_t getScanCode() const { return mScanCode; }
268
269 inline int32_t getMetaState() const { return mMetaState; }
270
271 inline int32_t getRepeatCount() const { return mRepeatCount; }
272
273 inline nsecs_t getDownTime() const { return mDownTime; }
274
275 inline nsecs_t getEventTime() const { return mEventTime; }
276
Dianne Hackborn3c80a4a2010-06-29 19:20:40 -0700277 // Return true if this event may have a default action implementation.
278 static bool hasDefaultAction(int32_t keyCode);
279 bool hasDefaultAction() const;
280
281 // Return true if this event represents a system key.
282 static bool isSystemKey(int32_t keyCode);
283 bool isSystemKey() const;
284
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700285 void initialize(
286 int32_t deviceId,
Jeff Brownc5ed5912010-07-14 18:48:53 -0700287 int32_t source,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700288 int32_t action,
289 int32_t flags,
290 int32_t keyCode,
291 int32_t scanCode,
292 int32_t metaState,
293 int32_t repeatCount,
294 nsecs_t downTime,
295 nsecs_t eventTime);
Dianne Hackborn2c6081c2010-07-15 17:44:53 -0700296 void initialize(const KeyEvent& from);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700297
Jeff Brown91c69ab2011-02-14 17:03:18 -0800298protected:
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700299 int32_t mAction;
300 int32_t mFlags;
301 int32_t mKeyCode;
302 int32_t mScanCode;
303 int32_t mMetaState;
304 int32_t mRepeatCount;
305 nsecs_t mDownTime;
306 nsecs_t mEventTime;
307};
308
Jeff Brown5c225b12010-06-16 01:53:36 -0700309/*
310 * Motion events.
311 */
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700312class MotionEvent : public InputEvent {
313public:
314 virtual ~MotionEvent() { }
315
Jeff Brownc5ed5912010-07-14 18:48:53 -0700316 virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700317
318 inline int32_t getAction() const { return mAction; }
319
Jeff Brown2ed24622011-03-14 19:39:54 -0700320 inline int32_t getActionMasked() const { return mAction & AMOTION_EVENT_ACTION_MASK; }
321
322 inline int32_t getActionIndex() const {
323 return (mAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
324 >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
325 }
326
Jeff Brown91c69ab2011-02-14 17:03:18 -0800327 inline void setAction(int32_t action) { mAction = action; }
328
Jeff Brown85a31762010-09-01 17:01:00 -0700329 inline int32_t getFlags() const { return mFlags; }
330
Jeff Brown21bc5c92011-02-28 18:27:14 -0800331 inline void setFlags(int32_t flags) { mFlags = flags; }
332
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700333 inline int32_t getEdgeFlags() const { return mEdgeFlags; }
334
Jeff Brown91c69ab2011-02-14 17:03:18 -0800335 inline void setEdgeFlags(int32_t edgeFlags) { mEdgeFlags = edgeFlags; }
336
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700337 inline int32_t getMetaState() const { return mMetaState; }
338
Jeff Brown91c69ab2011-02-14 17:03:18 -0800339 inline void setMetaState(int32_t metaState) { mMetaState = metaState; }
340
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700341 inline int32_t getButtonState() const { return mButtonState; }
342
Jeff Brown5c225b12010-06-16 01:53:36 -0700343 inline float getXOffset() const { return mXOffset; }
344
345 inline float getYOffset() const { return mYOffset; }
346
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700347 inline float getXPrecision() const { return mXPrecision; }
348
349 inline float getYPrecision() const { return mYPrecision; }
350
351 inline nsecs_t getDownTime() const { return mDownTime; }
352
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700353 inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700354
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700355 inline size_t getPointerCount() const { return mPointerProperties.size(); }
356
357 inline const PointerProperties* getPointerProperties(size_t pointerIndex) const {
358 return &mPointerProperties[pointerIndex];
359 }
360
361 inline int32_t getPointerId(size_t pointerIndex) const {
362 return mPointerProperties[pointerIndex].id;
363 }
364
365 inline int32_t getToolType(size_t pointerIndex) const {
366 return mPointerProperties[pointerIndex].toolType;
367 }
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700368
369 inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
370
Jeff Brown91c69ab2011-02-14 17:03:18 -0800371 const PointerCoords* getRawPointerCoords(size_t pointerIndex) const;
372
373 float getRawAxisValue(int32_t axis, size_t pointerIndex) const;
374
Jeff Brown5c225b12010-06-16 01:53:36 -0700375 inline float getRawX(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800376 return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700377 }
378
Jeff Brown5c225b12010-06-16 01:53:36 -0700379 inline float getRawY(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800380 return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700381 }
382
Jeff Brown91c69ab2011-02-14 17:03:18 -0800383 float getAxisValue(int32_t axis, size_t pointerIndex) const;
384
Jeff Brown5c225b12010-06-16 01:53:36 -0700385 inline float getX(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800386 return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
Jeff Brown5c225b12010-06-16 01:53:36 -0700387 }
388
389 inline float getY(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800390 return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
Jeff Brown5c225b12010-06-16 01:53:36 -0700391 }
392
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700393 inline float getPressure(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800394 return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700395 }
396
397 inline float getSize(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800398 return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700399 }
400
Jeff Brownc5ed5912010-07-14 18:48:53 -0700401 inline float getTouchMajor(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800402 return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700403 }
404
405 inline float getTouchMinor(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800406 return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700407 }
408
409 inline float getToolMajor(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800410 return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700411 }
412
413 inline float getToolMinor(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800414 return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700415 }
416
417 inline float getOrientation(size_t pointerIndex) const {
Jeff Brownebbd5d12011-02-17 13:01:34 -0800418 return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700419 }
420
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700421 inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; }
422
423 inline nsecs_t getHistoricalEventTime(size_t historicalIndex) const {
424 return mSampleEventTimes[historicalIndex];
425 }
426
Jeff Brown91c69ab2011-02-14 17:03:18 -0800427 const PointerCoords* getHistoricalRawPointerCoords(
428 size_t pointerIndex, size_t historicalIndex) const;
429
430 float getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,
431 size_t historicalIndex) const;
432
Jeff Brown5c225b12010-06-16 01:53:36 -0700433 inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800434 return getHistoricalRawAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800435 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700436 }
437
Jeff Brown5c225b12010-06-16 01:53:36 -0700438 inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800439 return getHistoricalRawAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800440 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700441 }
442
Jeff Brown91c69ab2011-02-14 17:03:18 -0800443 float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const;
444
Jeff Brown5c225b12010-06-16 01:53:36 -0700445 inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800446 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800447 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
Jeff Brown5c225b12010-06-16 01:53:36 -0700448 }
449
450 inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800451 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800452 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
Jeff Brown5c225b12010-06-16 01:53:36 -0700453 }
454
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700455 inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800456 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800457 AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700458 }
459
460 inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800461 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800462 AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex);
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700463 }
464
Jeff Brownc5ed5912010-07-14 18:48:53 -0700465 inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800466 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800467 AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700468 }
469
470 inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800471 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800472 AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700473 }
474
475 inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800476 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800477 AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700478 }
479
480 inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800481 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800482 AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700483 }
484
485 inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const {
Jeff Brown91c69ab2011-02-14 17:03:18 -0800486 return getHistoricalAxisValue(
Jeff Brownebbd5d12011-02-17 13:01:34 -0800487 AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex);
Jeff Brownc5ed5912010-07-14 18:48:53 -0700488 }
489
Jeff Brown2ed24622011-03-14 19:39:54 -0700490 ssize_t findPointerIndex(int32_t pointerId) const;
491
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700492 void initialize(
493 int32_t deviceId,
Jeff Brownc5ed5912010-07-14 18:48:53 -0700494 int32_t source,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700495 int32_t action,
Jeff Brown85a31762010-09-01 17:01:00 -0700496 int32_t flags,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700497 int32_t edgeFlags,
498 int32_t metaState,
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700499 int32_t buttonState,
Jeff Brown5c225b12010-06-16 01:53:36 -0700500 float xOffset,
501 float yOffset,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700502 float xPrecision,
503 float yPrecision,
504 nsecs_t downTime,
505 nsecs_t eventTime,
506 size_t pointerCount,
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700507 const PointerProperties* pointerProperties,
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700508 const PointerCoords* pointerCoords);
509
Jeff Brown91c69ab2011-02-14 17:03:18 -0800510 void copyFrom(const MotionEvent* other, bool keepHistory);
511
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700512 void addSample(
513 nsecs_t eventTime,
514 const PointerCoords* pointerCoords);
515
516 void offsetLocation(float xOffset, float yOffset);
517
Jeff Brown91c69ab2011-02-14 17:03:18 -0800518 void scale(float scaleFactor);
519
520#ifdef HAVE_ANDROID_OS
521 void transform(const SkMatrix* matrix);
522
523 status_t readFromParcel(Parcel* parcel);
524 status_t writeToParcel(Parcel* parcel) const;
525#endif
526
Jeff Brown56194eb2011-03-02 19:23:13 -0800527 static bool isTouchEvent(int32_t source, int32_t action);
528 inline bool isTouchEvent() const {
529 return isTouchEvent(mSource, mAction);
530 }
531
Jeff Brown5c225b12010-06-16 01:53:36 -0700532 // Low-level accessors.
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700533 inline const PointerProperties* getPointerProperties() const {
534 return mPointerProperties.array();
535 }
Jeff Brown5c225b12010-06-16 01:53:36 -0700536 inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
537 inline const PointerCoords* getSamplePointerCoords() const {
538 return mSamplePointerCoords.array();
539 }
540
Jeff Brown91c69ab2011-02-14 17:03:18 -0800541protected:
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700542 int32_t mAction;
Jeff Brown85a31762010-09-01 17:01:00 -0700543 int32_t mFlags;
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700544 int32_t mEdgeFlags;
545 int32_t mMetaState;
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700546 int32_t mButtonState;
Jeff Brown5c225b12010-06-16 01:53:36 -0700547 float mXOffset;
548 float mYOffset;
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700549 float mXPrecision;
550 float mYPrecision;
551 nsecs_t mDownTime;
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700552 Vector<PointerProperties> mPointerProperties;
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700553 Vector<nsecs_t> mSampleEventTimes;
554 Vector<PointerCoords> mSamplePointerCoords;
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700555};
556
557/*
558 * Input event factory.
559 */
560class InputEventFactoryInterface {
561protected:
562 virtual ~InputEventFactoryInterface() { }
563
564public:
565 InputEventFactoryInterface() { }
566
567 virtual KeyEvent* createKeyEvent() = 0;
568 virtual MotionEvent* createMotionEvent() = 0;
569};
570
571/*
572 * A simple input event factory implementation that uses a single preallocated instance
573 * of each type of input event that are reused for each request.
574 */
575class PreallocatedInputEventFactory : public InputEventFactoryInterface {
576public:
577 PreallocatedInputEventFactory() { }
578 virtual ~PreallocatedInputEventFactory() { }
579
580 virtual KeyEvent* createKeyEvent() { return & mKeyEvent; }
581 virtual MotionEvent* createMotionEvent() { return & mMotionEvent; }
582
583private:
584 KeyEvent mKeyEvent;
585 MotionEvent mMotionEvent;
586};
587
Jeff Brown6d0fec22010-07-23 21:28:06 -0700588/*
Jeff Brown2b6c32c2012-03-13 15:00:09 -0700589 * An input event factory implementation that maintains a pool of input events.
590 */
591class PooledInputEventFactory : public InputEventFactoryInterface {
592public:
593 PooledInputEventFactory(size_t maxPoolSize = 20);
594 virtual ~PooledInputEventFactory();
595
596 virtual KeyEvent* createKeyEvent();
597 virtual MotionEvent* createMotionEvent();
598
599 void recycle(InputEvent* event);
600
601private:
602 const size_t mMaxPoolSize;
603
604 Vector<KeyEvent*> mKeyEventPool;
605 Vector<MotionEvent*> mMotionEventPool;
606};
607
Jeff Brown46b9ac0a2010-04-22 18:58:52 -0700608} // namespace android
609
Mathias Agopianb93a03f82012-02-17 15:34:57 -0800610#endif // _ANDROIDFW_INPUT_H