1 /*
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 
17 #ifndef _LIBINPUT_INPUT_H
18 #define _LIBINPUT_INPUT_H
19 
20 #pragma GCC system_header
21 
22 /**
23  * Native input event structures.
24  */
25 
26 #include <android/input.h>
27 #include <utils/BitSet.h>
28 #include <utils/KeyedVector.h>
29 #include <utils/RefBase.h>
30 #include <utils/Timers.h>
31 #include <utils/Vector.h>
32 #include <stdint.h>
33 
34 /*
35  * Additional private constants not defined in ndk/ui/input.h.
36  */
37 enum {
38     /* Signifies that the key is being predispatched */
39     AKEY_EVENT_FLAG_PREDISPATCH = 0x20000000,
40 
41     /* Private control to determine when an app is tracking a key sequence. */
42     AKEY_EVENT_FLAG_START_TRACKING = 0x40000000,
43 
44     /* Key event is inconsistent with previously sent key events. */
45     AKEY_EVENT_FLAG_TAINTED = 0x80000000,
46 };
47 
48 enum {
49 
50     /**
51      * This flag indicates that the window that received this motion event is partly
52      * or wholly obscured by another visible window above it.  This flag is set to true
53      * even if the event did not directly pass through the obscured area.
54      * A security sensitive application can check this flag to identify situations in which
55      * a malicious application may have covered up part of its content for the purpose
56      * of misleading the user or hijacking touches.  An appropriate response might be
57      * to drop the suspect touches or to take additional precautions to confirm the user's
58      * actual intent.
59      */
60     AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED = 0x2,
61 
62     /**
63      * This flag indicates that the event has been generated by a gesture generator. It
64      * provides a hint to the GestureDetector to not apply any touch slop.
65      */
66     AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE = 0x8,
67 
68     /* Motion event is inconsistent with previously sent motion events. */
69     AMOTION_EVENT_FLAG_TAINTED = 0x80000000,
70 };
71 
72 enum {
73     /* Used when a motion event is not associated with any display.
74      * Typically used for non-pointer events. */
75     ADISPLAY_ID_NONE = -1,
76 
77     /* The default display id. */
78     ADISPLAY_ID_DEFAULT = 0,
79 };
80 
81 enum {
82     /*
83      * Indicates that an input device has switches.
84      * This input source flag is hidden from the API because switches are only used by the system
85      * and applications have no way to interact with them.
86      */
87     AINPUT_SOURCE_SWITCH = 0x80000000,
88 };
89 
90 enum {
91     /**
92      * Constants for LEDs. Hidden from the API since we don't actually expose a way to interact
93      * with LEDs to developers
94      *
95      * NOTE: If you add LEDs here, you must also add them to InputEventLabels.h
96      */
97 
98     ALED_NUM_LOCK = 0x00,
99     ALED_CAPS_LOCK = 0x01,
100     ALED_SCROLL_LOCK = 0x02,
101     ALED_COMPOSE = 0x03,
102     ALED_KANA = 0x04,
103     ALED_SLEEP = 0x05,
104     ALED_SUSPEND = 0x06,
105     ALED_MUTE = 0x07,
106     ALED_MISC = 0x08,
107     ALED_MAIL = 0x09,
108     ALED_CHARGING = 0x0a,
109     ALED_CONTROLLER_1 = 0x10,
110     ALED_CONTROLLER_2 = 0x11,
111     ALED_CONTROLLER_3 = 0x12,
112     ALED_CONTROLLER_4 = 0x13,
113 };
114 
115 /* Maximum number of controller LEDs we support */
116 #define MAX_CONTROLLER_LEDS 4
117 
118 /*
119  * SystemUiVisibility constants from View.
120  */
121 enum {
122     ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE = 0,
123     ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN = 0x00000001,
124 };
125 
126 /*
127  * Maximum number of pointers supported per motion event.
128  * Smallest number of pointers is 1.
129  * (We want at least 10 but some touch controllers obstensibly configured for 10 pointers
130  * will occasionally emit 11.  There is not much harm making this constant bigger.)
131  */
132 #define MAX_POINTERS 16
133 
134 /*
135  * Maximum number of samples supported per motion event.
136  */
137 #define MAX_SAMPLES UINT16_MAX
138 
139 /*
140  * Maximum pointer id value supported in a motion event.
141  * Smallest pointer id is 0.
142  * (This is limited by our use of BitSet32 to track pointer assignments.)
143  */
144 #define MAX_POINTER_ID 31
145 
146 /*
147  * Declare a concrete type for the NDK's input event forward declaration.
148  */
149 struct AInputEvent {
~AInputEventAInputEvent150     virtual ~AInputEvent() { }
151 };
152 
153 /*
154  * Declare a concrete type for the NDK's input device forward declaration.
155  */
156 struct AInputDevice {
~AInputDeviceAInputDevice157     virtual ~AInputDevice() { }
158 };
159 
160 
161 namespace android {
162 
163 #ifdef __ANDROID__
164 class Parcel;
165 #endif
166 
167 /*
168  * Flags that flow alongside events in the input dispatch system to help with certain
169  * policy decisions such as waking from device sleep.
170  *
171  * These flags are also defined in frameworks/base/core/java/android/view/WindowManagerPolicy.java.
172  */
173 enum {
174     /* These flags originate in RawEvents and are generally set in the key map.
175      * NOTE: If you want a flag to be able to set in a keylayout file, then you must add it to
176      * InputEventLabels.h as well. */
177 
178     // Indicates that the event should wake the device.
179     POLICY_FLAG_WAKE = 0x00000001,
180 
181     // Indicates that the key is virtual, such as a capacitive button, and should
182     // generate haptic feedback.  Virtual keys may be suppressed for some time
183     // after a recent touch to prevent accidental activation of virtual keys adjacent
184     // to the touch screen during an edge swipe.
185     POLICY_FLAG_VIRTUAL = 0x00000002,
186 
187     // Indicates that the key is the special function modifier.
188     POLICY_FLAG_FUNCTION = 0x00000004,
189 
190     // Indicates that the key represents a special gesture that has been detected by
191     // the touch firmware or driver.  Causes touch events from the same device to be canceled.
192     POLICY_FLAG_GESTURE = 0x00000008,
193 
194     POLICY_FLAG_RAW_MASK = 0x0000ffff,
195 
196     /* These flags are set by the input dispatcher. */
197 
198     // Indicates that the input event was injected.
199     POLICY_FLAG_INJECTED = 0x01000000,
200 
201     // Indicates that the input event is from a trusted source such as a directly attached
202     // input device or an application with system-wide event injection permission.
203     POLICY_FLAG_TRUSTED = 0x02000000,
204 
205     // Indicates that the input event has passed through an input filter.
206     POLICY_FLAG_FILTERED = 0x04000000,
207 
208     // Disables automatic key repeating behavior.
209     POLICY_FLAG_DISABLE_KEY_REPEAT = 0x08000000,
210 
211     /* These flags are set by the input reader policy as it intercepts each event. */
212 
213     // Indicates that the device was in an interactive state when the
214     // event was intercepted.
215     POLICY_FLAG_INTERACTIVE = 0x20000000,
216 
217     // Indicates that the event should be dispatched to applications.
218     // The input event should still be sent to the InputDispatcher so that it can see all
219     // input events received include those that it will not deliver.
220     POLICY_FLAG_PASS_TO_USER = 0x40000000,
221 };
222 
223 /**
224  * Classifications of the current gesture, if available.
225  *
226  * The following values must be kept in sync with MotionEvent.java
227  */
228 enum class MotionClassification : uint8_t {
229     /**
230      * No classification is available.
231      */
232     NONE = 0,
233     /**
234      * Too early to classify the current gesture. Need more events. Look for changes in the
235      * upcoming motion events.
236      */
237     AMBIGUOUS_GESTURE = 1,
238     /**
239      * The current gesture likely represents a user intentionally exerting force on the touchscreen.
240      */
241     DEEP_PRESS = 2,
242 };
243 
244 /**
245  * String representation of MotionClassification
246  */
247 const char* motionClassificationToString(MotionClassification classification);
248 
249 /*
250  * Pointer coordinate data.
251  */
252 struct PointerCoords {
253     enum { MAX_AXES = 30 }; // 30 so that sizeof(PointerCoords) == 128
254 
255     // Bitfield of axes that are present in this structure.
256     uint64_t bits __attribute__((aligned(8)));
257 
258     // Values of axes that are stored in this structure packed in order by axis id
259     // for each axis that is present in the structure according to 'bits'.
260     float values[MAX_AXES];
261 
clearPointerCoords262     inline void clear() {
263         BitSet64::clear(bits);
264     }
265 
isEmptyPointerCoords266     bool isEmpty() const {
267         return BitSet64::isEmpty(bits);
268     }
269 
270     float getAxisValue(int32_t axis) const;
271     status_t setAxisValue(int32_t axis, float value);
272 
273     void scale(float globalScale);
274 
275     // Scale the pointer coordinates according to a global scale and a
276     // window scale. The global scale will be applied to TOUCH/TOOL_MAJOR/MINOR
277     // axes, however the window scaling will not.
278     void scale(float globalScale, float windowXScale, float windowYScale);
279     void applyOffset(float xOffset, float yOffset);
280 
getXPointerCoords281     inline float getX() const {
282         return getAxisValue(AMOTION_EVENT_AXIS_X);
283     }
284 
getYPointerCoords285     inline float getY() const {
286         return getAxisValue(AMOTION_EVENT_AXIS_Y);
287     }
288 
289 #ifdef __ANDROID__
290     status_t readFromParcel(Parcel* parcel);
291     status_t writeToParcel(Parcel* parcel) const;
292 #endif
293 
294     bool operator==(const PointerCoords& other) const;
295     inline bool operator!=(const PointerCoords& other) const {
296         return !(*this == other);
297     }
298 
299     void copyFrom(const PointerCoords& other);
300 
301 private:
302     void tooManyAxes(int axis);
303 };
304 
305 /*
306  * Pointer property data.
307  */
308 struct PointerProperties {
309     // The id of the pointer.
310     int32_t id;
311 
312     // The pointer tool type.
313     int32_t toolType;
314 
clearPointerProperties315     inline void clear() {
316         id = -1;
317         toolType = 0;
318     }
319 
320     bool operator==(const PointerProperties& other) const;
321     inline bool operator!=(const PointerProperties& other) const {
322         return !(*this == other);
323     }
324 
325     void copyFrom(const PointerProperties& other);
326 };
327 
328 /*
329  * Input events.
330  */
331 class InputEvent : public AInputEvent {
332 public:
~InputEvent()333     virtual ~InputEvent() { }
334 
335     virtual int32_t getType() const = 0;
336 
getDeviceId()337     inline int32_t getDeviceId() const { return mDeviceId; }
338 
getSource()339     inline int32_t getSource() const { return mSource; }
340 
setSource(int32_t source)341     inline void setSource(int32_t source) { mSource = source; }
342 
getDisplayId()343     inline int32_t getDisplayId() const { return mDisplayId; }
344 
setDisplayId(int32_t displayId)345     inline void setDisplayId(int32_t displayId) { mDisplayId = displayId; }
346 
347 
348 protected:
349     void initialize(int32_t deviceId, int32_t source, int32_t displayId);
350     void initialize(const InputEvent& from);
351 
352     int32_t mDeviceId;
353     int32_t mSource;
354     int32_t mDisplayId;
355 };
356 
357 /*
358  * Key events.
359  */
360 class KeyEvent : public InputEvent {
361 public:
~KeyEvent()362     virtual ~KeyEvent() { }
363 
getType()364     virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }
365 
getAction()366     inline int32_t getAction() const { return mAction; }
367 
getFlags()368     inline int32_t getFlags() const { return mFlags; }
369 
setFlags(int32_t flags)370     inline void setFlags(int32_t flags) { mFlags = flags; }
371 
getKeyCode()372     inline int32_t getKeyCode() const { return mKeyCode; }
373 
getScanCode()374     inline int32_t getScanCode() const { return mScanCode; }
375 
getMetaState()376     inline int32_t getMetaState() const { return mMetaState; }
377 
getRepeatCount()378     inline int32_t getRepeatCount() const { return mRepeatCount; }
379 
getDownTime()380     inline nsecs_t getDownTime() const { return mDownTime; }
381 
getEventTime()382     inline nsecs_t getEventTime() const { return mEventTime; }
383 
384     static const char* getLabel(int32_t keyCode);
385     static int32_t getKeyCodeFromLabel(const char* label);
386 
387     void initialize(
388             int32_t deviceId,
389             int32_t source,
390             int32_t displayId,
391             int32_t action,
392             int32_t flags,
393             int32_t keyCode,
394             int32_t scanCode,
395             int32_t metaState,
396             int32_t repeatCount,
397             nsecs_t downTime,
398             nsecs_t eventTime);
399     void initialize(const KeyEvent& from);
400 
401 protected:
402     int32_t mAction;
403     int32_t mFlags;
404     int32_t mKeyCode;
405     int32_t mScanCode;
406     int32_t mMetaState;
407     int32_t mRepeatCount;
408     nsecs_t mDownTime;
409     nsecs_t mEventTime;
410 };
411 
412 /*
413  * Motion events.
414  */
415 class MotionEvent : public InputEvent {
416 public:
~MotionEvent()417     virtual ~MotionEvent() { }
418 
getType()419     virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }
420 
getAction()421     inline int32_t getAction() const { return mAction; }
422 
getActionMasked()423     inline int32_t getActionMasked() const { return mAction & AMOTION_EVENT_ACTION_MASK; }
424 
getActionIndex()425     inline int32_t getActionIndex() const {
426         return (mAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
427                 >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
428     }
429 
setAction(int32_t action)430     inline void setAction(int32_t action) { mAction = action; }
431 
getFlags()432     inline int32_t getFlags() const { return mFlags; }
433 
setFlags(int32_t flags)434     inline void setFlags(int32_t flags) { mFlags = flags; }
435 
getEdgeFlags()436     inline int32_t getEdgeFlags() const { return mEdgeFlags; }
437 
setEdgeFlags(int32_t edgeFlags)438     inline void setEdgeFlags(int32_t edgeFlags) { mEdgeFlags = edgeFlags; }
439 
getMetaState()440     inline int32_t getMetaState() const { return mMetaState; }
441 
setMetaState(int32_t metaState)442     inline void setMetaState(int32_t metaState) { mMetaState = metaState; }
443 
getButtonState()444     inline int32_t getButtonState() const { return mButtonState; }
445 
setButtonState(int32_t buttonState)446     inline void setButtonState(int32_t buttonState) { mButtonState = buttonState; }
447 
getClassification()448     inline MotionClassification getClassification() const { return mClassification; }
449 
getActionButton()450     inline int32_t getActionButton() const { return mActionButton; }
451 
setActionButton(int32_t button)452     inline void setActionButton(int32_t button) { mActionButton = button; }
453 
getXOffset()454     inline float getXOffset() const { return mXOffset; }
455 
getYOffset()456     inline float getYOffset() const { return mYOffset; }
457 
getXPrecision()458     inline float getXPrecision() const { return mXPrecision; }
459 
getYPrecision()460     inline float getYPrecision() const { return mYPrecision; }
461 
getDownTime()462     inline nsecs_t getDownTime() const { return mDownTime; }
463 
setDownTime(nsecs_t downTime)464     inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
465 
getPointerCount()466     inline size_t getPointerCount() const { return mPointerProperties.size(); }
467 
getPointerProperties(size_t pointerIndex)468     inline const PointerProperties* getPointerProperties(size_t pointerIndex) const {
469         return &mPointerProperties[pointerIndex];
470     }
471 
getPointerId(size_t pointerIndex)472     inline int32_t getPointerId(size_t pointerIndex) const {
473         return mPointerProperties[pointerIndex].id;
474     }
475 
getToolType(size_t pointerIndex)476     inline int32_t getToolType(size_t pointerIndex) const {
477         return mPointerProperties[pointerIndex].toolType;
478     }
479 
getEventTime()480     inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
481 
482     const PointerCoords* getRawPointerCoords(size_t pointerIndex) const;
483 
484     float getRawAxisValue(int32_t axis, size_t pointerIndex) const;
485 
getRawX(size_t pointerIndex)486     inline float getRawX(size_t pointerIndex) const {
487         return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
488     }
489 
getRawY(size_t pointerIndex)490     inline float getRawY(size_t pointerIndex) const {
491         return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
492     }
493 
494     float getAxisValue(int32_t axis, size_t pointerIndex) const;
495 
getX(size_t pointerIndex)496     inline float getX(size_t pointerIndex) const {
497         return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
498     }
499 
getY(size_t pointerIndex)500     inline float getY(size_t pointerIndex) const {
501         return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
502     }
503 
getPressure(size_t pointerIndex)504     inline float getPressure(size_t pointerIndex) const {
505         return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex);
506     }
507 
getSize(size_t pointerIndex)508     inline float getSize(size_t pointerIndex) const {
509         return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex);
510     }
511 
getTouchMajor(size_t pointerIndex)512     inline float getTouchMajor(size_t pointerIndex) const {
513         return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex);
514     }
515 
getTouchMinor(size_t pointerIndex)516     inline float getTouchMinor(size_t pointerIndex) const {
517         return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex);
518     }
519 
getToolMajor(size_t pointerIndex)520     inline float getToolMajor(size_t pointerIndex) const {
521         return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex);
522     }
523 
getToolMinor(size_t pointerIndex)524     inline float getToolMinor(size_t pointerIndex) const {
525         return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex);
526     }
527 
getOrientation(size_t pointerIndex)528     inline float getOrientation(size_t pointerIndex) const {
529         return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex);
530     }
531 
getHistorySize()532     inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; }
533 
getHistoricalEventTime(size_t historicalIndex)534     inline nsecs_t getHistoricalEventTime(size_t historicalIndex) const {
535         return mSampleEventTimes[historicalIndex];
536     }
537 
538     const PointerCoords* getHistoricalRawPointerCoords(
539             size_t pointerIndex, size_t historicalIndex) const;
540 
541     float getHistoricalRawAxisValue(int32_t axis, size_t pointerIndex,
542             size_t historicalIndex) const;
543 
getHistoricalRawX(size_t pointerIndex,size_t historicalIndex)544     inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const {
545         return getHistoricalRawAxisValue(
546                 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
547     }
548 
getHistoricalRawY(size_t pointerIndex,size_t historicalIndex)549     inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const {
550         return getHistoricalRawAxisValue(
551                 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
552     }
553 
554     float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const;
555 
getHistoricalX(size_t pointerIndex,size_t historicalIndex)556     inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const {
557         return getHistoricalAxisValue(
558                 AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
559     }
560 
getHistoricalY(size_t pointerIndex,size_t historicalIndex)561     inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const {
562         return getHistoricalAxisValue(
563                 AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
564     }
565 
getHistoricalPressure(size_t pointerIndex,size_t historicalIndex)566     inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const {
567         return getHistoricalAxisValue(
568                 AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex);
569     }
570 
getHistoricalSize(size_t pointerIndex,size_t historicalIndex)571     inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const {
572         return getHistoricalAxisValue(
573                 AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex);
574     }
575 
getHistoricalTouchMajor(size_t pointerIndex,size_t historicalIndex)576     inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const {
577         return getHistoricalAxisValue(
578                 AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
579     }
580 
getHistoricalTouchMinor(size_t pointerIndex,size_t historicalIndex)581     inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const {
582         return getHistoricalAxisValue(
583                 AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
584     }
585 
getHistoricalToolMajor(size_t pointerIndex,size_t historicalIndex)586     inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const {
587         return getHistoricalAxisValue(
588                 AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
589     }
590 
getHistoricalToolMinor(size_t pointerIndex,size_t historicalIndex)591     inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const {
592         return getHistoricalAxisValue(
593                 AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
594     }
595 
getHistoricalOrientation(size_t pointerIndex,size_t historicalIndex)596     inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const {
597         return getHistoricalAxisValue(
598                 AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex);
599     }
600 
601     ssize_t findPointerIndex(int32_t pointerId) const;
602 
603     void initialize(
604             int32_t deviceId,
605             int32_t source,
606             int32_t displayId,
607             int32_t action,
608             int32_t actionButton,
609             int32_t flags,
610             int32_t edgeFlags,
611             int32_t metaState,
612             int32_t buttonState,
613             MotionClassification classification,
614             float xOffset,
615             float yOffset,
616             float xPrecision,
617             float yPrecision,
618             nsecs_t downTime,
619             nsecs_t eventTime,
620             size_t pointerCount,
621             const PointerProperties* pointerProperties,
622             const PointerCoords* pointerCoords);
623 
624     void copyFrom(const MotionEvent* other, bool keepHistory);
625 
626     void addSample(
627             nsecs_t eventTime,
628             const PointerCoords* pointerCoords);
629 
630     void offsetLocation(float xOffset, float yOffset);
631 
632     void scale(float globalScaleFactor);
633 
634     // Apply 3x3 perspective matrix transformation.
635     // Matrix is in row-major form and compatible with SkMatrix.
636     void transform(const float matrix[9]);
637 
638 #ifdef __ANDROID__
639     status_t readFromParcel(Parcel* parcel);
640     status_t writeToParcel(Parcel* parcel) const;
641 #endif
642 
643     static bool isTouchEvent(int32_t source, int32_t action);
isTouchEvent()644     inline bool isTouchEvent() const {
645         return isTouchEvent(mSource, mAction);
646     }
647 
648     // Low-level accessors.
getPointerProperties()649     inline const PointerProperties* getPointerProperties() const {
650         return mPointerProperties.array();
651     }
getSampleEventTimes()652     inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
getSamplePointerCoords()653     inline const PointerCoords* getSamplePointerCoords() const {
654             return mSamplePointerCoords.array();
655     }
656 
657     static const char* getLabel(int32_t axis);
658     static int32_t getAxisFromLabel(const char* label);
659 
660 protected:
661     int32_t mAction;
662     int32_t mActionButton;
663     int32_t mFlags;
664     int32_t mEdgeFlags;
665     int32_t mMetaState;
666     int32_t mButtonState;
667     MotionClassification mClassification;
668     float mXOffset;
669     float mYOffset;
670     float mXPrecision;
671     float mYPrecision;
672     nsecs_t mDownTime;
673     Vector<PointerProperties> mPointerProperties;
674     Vector<nsecs_t> mSampleEventTimes;
675     Vector<PointerCoords> mSamplePointerCoords;
676 };
677 
678 /*
679  * Input event factory.
680  */
681 class InputEventFactoryInterface {
682 protected:
~InputEventFactoryInterface()683     virtual ~InputEventFactoryInterface() { }
684 
685 public:
InputEventFactoryInterface()686     InputEventFactoryInterface() { }
687 
688     virtual KeyEvent* createKeyEvent() = 0;
689     virtual MotionEvent* createMotionEvent() = 0;
690 };
691 
692 /*
693  * A simple input event factory implementation that uses a single preallocated instance
694  * of each type of input event that are reused for each request.
695  */
696 class PreallocatedInputEventFactory : public InputEventFactoryInterface {
697 public:
PreallocatedInputEventFactory()698     PreallocatedInputEventFactory() { }
~PreallocatedInputEventFactory()699     virtual ~PreallocatedInputEventFactory() { }
700 
createKeyEvent()701     virtual KeyEvent* createKeyEvent() { return & mKeyEvent; }
createMotionEvent()702     virtual MotionEvent* createMotionEvent() { return & mMotionEvent; }
703 
704 private:
705     KeyEvent mKeyEvent;
706     MotionEvent mMotionEvent;
707 };
708 
709 /*
710  * An input event factory implementation that maintains a pool of input events.
711  */
712 class PooledInputEventFactory : public InputEventFactoryInterface {
713 public:
714     explicit PooledInputEventFactory(size_t maxPoolSize = 20);
715     virtual ~PooledInputEventFactory();
716 
717     virtual KeyEvent* createKeyEvent();
718     virtual MotionEvent* createMotionEvent();
719 
720     void recycle(InputEvent* event);
721 
722 private:
723     const size_t mMaxPoolSize;
724 
725     Vector<KeyEvent*> mKeyEventPool;
726     Vector<MotionEvent*> mMotionEventPool;
727 };
728 
729 } // namespace android
730 
731 #endif // _LIBINPUT_INPUT_H
732