2
* Copyright (C) 2010 The Android Open Source Project
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
8
* http://www.apache.org/licenses/LICENSE-2.0
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.
17
#ifndef _ANDROIDFW_INPUT_H
18
#define _ANDROIDFW_INPUT_H
21
* Native input event structures.
24
#include <android/input.h>
25
#include <utils/Vector.h>
26
#include <utils/KeyedVector.h>
27
#include <utils/Timers.h>
28
#include <utils/RefBase.h>
29
#include <utils/String8.h>
31
#ifdef HAVE_ANDROID_OS
36
* Additional private constants not defined in ndk/ui/input.h.
39
/* Private control to determine when an app is tracking a key sequence. */
40
AKEY_EVENT_FLAG_START_TRACKING = 0x40000000,
42
/* Key event is inconsistent with previously sent key events. */
43
AKEY_EVENT_FLAG_TAINTED = 0x80000000,
47
/* Motion event is inconsistent with previously sent motion events. */
48
AMOTION_EVENT_FLAG_TAINTED = 0x80000000,
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.
57
AINPUT_SOURCE_SWITCH = 0x80000000,
61
* SystemUiVisibility constants from View.
64
ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE = 0,
65
ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN = 0x00000001,
69
* Maximum number of pointers supported per motion event.
70
* Smallest number of pointers is 1.
71
* (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.)
74
#define MAX_POINTERS 16
77
* 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.)
81
#define MAX_POINTER_ID 31
84
* Declare a concrete type for the NDK's input event forward declaration.
87
virtual ~AInputEvent() { }
91
* Declare a concrete type for the NDK's input device forward declaration.
94
virtual ~AInputDevice() { }
100
#ifdef HAVE_ANDROID_OS
105
* Flags that flow alongside events in the input dispatch system to help with certain
106
* policy decisions such as waking from device sleep.
108
* These flags are also defined in frameworks/base/core/java/android/view/WindowManagerPolicy.java.
111
/* These flags originate in RawEvents and are generally set in the key map.
112
* NOTE: If you edit these flags, also edit labels in KeycodeLabels.h. */
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,
122
POLICY_FLAG_VIRTUAL = 0x00000100,
123
POLICY_FLAG_FUNCTION = 0x00000200,
125
POLICY_FLAG_RAW_MASK = 0x0000ffff,
127
/* These flags are set by the input dispatcher. */
129
// Indicates that the input event was injected.
130
POLICY_FLAG_INJECTED = 0x01000000,
132
// 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,
136
// Indicates that the input event has passed through an input filter.
137
POLICY_FLAG_FILTERED = 0x04000000,
139
// Disables automatic key repeating behavior.
140
POLICY_FLAG_DISABLE_KEY_REPEAT = 0x08000000,
142
/* These flags are set by the input reader policy as it intercepts each event. */
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,
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,
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,
159
* Pointer coordinate data.
161
struct PointerCoords {
162
enum { MAX_AXES = 14 }; // 14 so that sizeof(PointerCoords) == 64
164
// Bitfield of axes that are present in this structure.
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];
171
inline void clear() {
175
float getAxisValue(int32_t axis) const;
176
status_t setAxisValue(int32_t axis, float value);
178
void scale(float scale);
180
inline float getX() const {
181
return getAxisValue(AMOTION_EVENT_AXIS_X);
184
inline float getY() const {
185
return getAxisValue(AMOTION_EVENT_AXIS_Y);
188
#ifdef HAVE_ANDROID_OS
189
status_t readFromParcel(Parcel* parcel);
190
status_t writeToParcel(Parcel* parcel) const;
193
bool operator==(const PointerCoords& other) const;
194
inline bool operator!=(const PointerCoords& other) const {
195
return !(*this == other);
198
void copyFrom(const PointerCoords& other);
201
void tooManyAxes(int axis);
205
* Pointer property data.
207
struct PointerProperties {
208
// The id of the pointer.
211
// The pointer tool type.
214
inline void clear() {
219
bool operator==(const PointerProperties& other) const;
220
inline bool operator!=(const PointerProperties& other) const {
221
return !(*this == other);
224
void copyFrom(const PointerProperties& other);
230
class InputEvent : public AInputEvent {
232
virtual ~InputEvent() { }
234
virtual int32_t getType() const = 0;
236
inline int32_t getDeviceId() const { return mDeviceId; }
238
inline int32_t getSource() const { return mSource; }
240
inline void setSource(int32_t source) { mSource = source; }
243
void initialize(int32_t deviceId, int32_t source);
244
void initialize(const InputEvent& from);
253
class KeyEvent : public InputEvent {
255
virtual ~KeyEvent() { }
257
virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }
259
inline int32_t getAction() const { return mAction; }
261
inline int32_t getFlags() const { return mFlags; }
263
inline void setFlags(int32_t flags) { mFlags = flags; }
265
inline int32_t getKeyCode() const { return mKeyCode; }
267
inline int32_t getScanCode() const { return mScanCode; }
269
inline int32_t getMetaState() const { return mMetaState; }
271
inline int32_t getRepeatCount() const { return mRepeatCount; }
273
inline nsecs_t getDownTime() const { return mDownTime; }
275
inline nsecs_t getEventTime() const { return mEventTime; }
277
// Return true if this event may have a default action implementation.
278
static bool hasDefaultAction(int32_t keyCode);
279
bool hasDefaultAction() const;
281
// Return true if this event represents a system key.
282
static bool isSystemKey(int32_t keyCode);
283
bool isSystemKey() const;
296
void initialize(const KeyEvent& from);
304
int32_t mRepeatCount;
312
class MotionEvent : public InputEvent {
314
virtual ~MotionEvent() { }
316
virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }
318
inline int32_t getAction() const { return mAction; }
320
inline int32_t getActionMasked() const { return mAction & AMOTION_EVENT_ACTION_MASK; }
322
inline int32_t getActionIndex() const {
323
return (mAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
324
>> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
327
inline void setAction(int32_t action) { mAction = action; }
329
inline int32_t getFlags() const { return mFlags; }
331
inline void setFlags(int32_t flags) { mFlags = flags; }
333
inline int32_t getEdgeFlags() const { return mEdgeFlags; }
335
inline void setEdgeFlags(int32_t edgeFlags) { mEdgeFlags = edgeFlags; }
337
inline int32_t getMetaState() const { return mMetaState; }
339
inline void setMetaState(int32_t metaState) { mMetaState = metaState; }
341
inline int32_t getButtonState() const { return mButtonState; }
343
inline float getXOffset() const { return mXOffset; }
345
inline float getYOffset() const { return mYOffset; }
347
inline float getXPrecision() const { return mXPrecision; }
349
inline float getYPrecision() const { return mYPrecision; }
351
inline nsecs_t getDownTime() const { return mDownTime; }
353
inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
355
inline size_t getPointerCount() const { return mPointerProperties.size(); }
357
inline const PointerProperties* getPointerProperties(size_t pointerIndex) const {
358
return &mPointerProperties[pointerIndex];
361
inline int32_t getPointerId(size_t pointerIndex) const {
362
return mPointerProperties[pointerIndex].id;
365
inline int32_t getToolType(size_t pointerIndex) const {
366
return mPointerProperties[pointerIndex].toolType;
369
inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
371
const PointerCoords* getRawPointerCoords(size_t pointerIndex) const;
373
float getRawAxisValue(int32_t axis, size_t pointerIndex) const;
375
inline float getRawX(size_t pointerIndex) const {
376
return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
379
inline float getRawY(size_t pointerIndex) const {
380
return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
383
float getAxisValue(int32_t axis, size_t pointerIndex) const;
385
inline float getX(size_t pointerIndex) const {
386
return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
389
inline float getY(size_t pointerIndex) const {
390
return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
393
inline float getPressure(size_t pointerIndex) const {
394
return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex);
397
inline float getSize(size_t pointerIndex) const {
398
return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex);
401
inline float getTouchMajor(size_t pointerIndex) const {
402
return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex);
405
inline float getTouchMinor(size_t pointerIndex) const {
406
return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex);
409
inline float getToolMajor(size_t pointerIndex) const {
410
return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex);
413
inline float getToolMinor(size_t pointerIndex) const {
414
return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex);
417
inline float getOrientation(size_t pointerIndex) const {
418
return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex);
421
inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; }
423
inline nsecs_t getHistoricalEventTime(size_t historicalIndex) const {
424
return mSampleEventTimes[historicalIndex];
427
const PointerCoords* getHistoricalRawPointerCoords(
428
size_t pointerIndex, size_t historicalIndex) const;
430
float getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,
431
size_t historicalIndex) const;
433
inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const {
434
return getHistoricalRawAxisValue(
435
AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
438
inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const {
439
return getHistoricalRawAxisValue(
440
AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
443
float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const;
445
inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const {
446
return getHistoricalAxisValue(
447
AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
450
inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const {
451
return getHistoricalAxisValue(
452
AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
455
inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const {
456
return getHistoricalAxisValue(
457
AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex);
460
inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const {
461
return getHistoricalAxisValue(
462
AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex);
465
inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const {
466
return getHistoricalAxisValue(
467
AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
470
inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const {
471
return getHistoricalAxisValue(
472
AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
475
inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const {
476
return getHistoricalAxisValue(
477
AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
480
inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const {
481
return getHistoricalAxisValue(
482
AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
485
inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const {
486
return getHistoricalAxisValue(
487
AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex);
490
ssize_t findPointerIndex(int32_t pointerId) const;
507
const PointerProperties* pointerProperties,
508
const PointerCoords* pointerCoords);
510
void copyFrom(const MotionEvent* other, bool keepHistory);
514
const PointerCoords* pointerCoords);
516
void offsetLocation(float xOffset, float yOffset);
518
void scale(float scaleFactor);
520
#ifdef HAVE_ANDROID_OS
521
void transform(const SkMatrix* matrix);
523
status_t readFromParcel(Parcel* parcel);
524
status_t writeToParcel(Parcel* parcel) const;
527
static bool isTouchEvent(int32_t source, int32_t action);
528
inline bool isTouchEvent() const {
529
return isTouchEvent(mSource, mAction);
532
// Low-level accessors.
533
inline const PointerProperties* getPointerProperties() const {
534
return mPointerProperties.array();
536
inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
537
inline const PointerCoords* getSamplePointerCoords() const {
538
return mSamplePointerCoords.array();
546
int32_t mButtonState;
552
Vector<PointerProperties> mPointerProperties;
553
Vector<nsecs_t> mSampleEventTimes;
554
Vector<PointerCoords> mSamplePointerCoords;
558
* Input event factory.
560
class InputEventFactoryInterface {
562
virtual ~InputEventFactoryInterface() { }
565
InputEventFactoryInterface() { }
567
virtual KeyEvent* createKeyEvent() = 0;
568
virtual MotionEvent* createMotionEvent() = 0;
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.
575
class PreallocatedInputEventFactory : public InputEventFactoryInterface {
577
PreallocatedInputEventFactory() { }
578
virtual ~PreallocatedInputEventFactory() { }
580
virtual KeyEvent* createKeyEvent() { return & mKeyEvent; }
581
virtual MotionEvent* createMotionEvent() { return & mMotionEvent; }
585
MotionEvent mMotionEvent;
589
* An input event factory implementation that maintains a pool of input events.
591
class PooledInputEventFactory : public InputEventFactoryInterface {
593
PooledInputEventFactory(size_t maxPoolSize = 20);
594
virtual ~PooledInputEventFactory();
596
virtual KeyEvent* createKeyEvent();
597
virtual MotionEvent* createMotionEvent();
599
void recycle(InputEvent* event);
602
const size_t mMaxPoolSize;
604
Vector<KeyEvent*> mKeyEventPool;
605
Vector<MotionEvent*> mMotionEventPool;
608
} // namespace android
610
#endif // _ANDROIDFW_INPUT_H
added
removed
3rd_party/android-input/android_pristine/frameworks/base/include/androidfw/Input.h
