← Back to branch summary

~mir-team/mir/attestable-timestamps

« back to all changes in this revision

Viewing changes to 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h

Import android input stack

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h
 
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 _ANDROIDFW_INPUT_H
 
18
#define _ANDROIDFW_INPUT_H
 
19
 
 
20
/**
 
21
 * Native input event structures.
 
22
 */
 
23
 
 
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>
 
30
 
 
31
#ifdef HAVE_ANDROID_OS
 
32
class SkMatrix;
 
33
#endif
 
34
 
 
35
/*
 
36
 * Additional private constants not defined in ndk/ui/input.h.
 
37
 */
 
38
enum {
 
39
    /* 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
 
 
46
enum {
 
47
    /* Motion event is inconsistent with previously sent motion events. */
 
48
    AMOTION_EVENT_FLAG_TAINTED = 0x80000000
 
49
};
 
50
 
 
51
enum {
 
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
 
 
60
/*
 
61
 * SystemUiVisibility constants from View.
 
62
 */
 
63
enum {
 
64
    ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE = 0,
 
65
    ASYSTEM_UI_VISIBILITY_STATUS_BAR_HIDDEN = 0x00000001
 
66
};
 
67
 
 
68
/*
 
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.)
 
73
 */
 
74
#define MAX_POINTERS 16
 
75
 
 
76
/*
 
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.)
 
80
 */
 
81
#define MAX_POINTER_ID 31
 
82
 
 
83
/*
 
84
 * Declare a concrete type for the NDK's input event forward declaration.
 
85
 */
 
86
struct AInputEvent {
 
87
    virtual ~AInputEvent() { }
 
88
};
 
89
 
 
90
/*
 
91
 * Declare a concrete type for the NDK's input device forward declaration.
 
92
 */
 
93
struct AInputDevice {
 
94
    virtual ~AInputDevice() { }
 
95
};
 
96
 
 
97
 
 
98
namespace android {
 
99
 
 
100
#ifdef HAVE_ANDROID_OS
 
101
class Parcel;
 
102
#endif
 
103
 
 
104
/*
 
105
 * Flags that flow alongside events in the input dispatch system to help with certain
 
106
 * policy decisions such as waking from device sleep.
 
107
 *
 
108
 * These flags are also defined in frameworks/base/core/java/android/view/WindowManagerPolicy.java.
 
109
 */
 
110
enum {
 
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. */
 
113
 
 
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,
 
124
 
 
125
    POLICY_FLAG_RAW_MASK = 0x0000ffff,
 
126
 
 
127
    /* These flags are set by the input dispatcher. */
 
128
 
 
129
    // Indicates that the input event was injected.
 
130
    POLICY_FLAG_INJECTED = 0x01000000,
 
131
 
 
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,
 
135
 
 
136
    // 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
 
 
142
    /* These flags are set by the input reader policy as it intercepts each event. */
 
143
 
 
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,
 
151
 
 
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
 
156
};
 
157
 
 
158
/*
 
159
 * Pointer coordinate data.
 
160
 */
 
161
struct PointerCoords {
 
162
    enum { MAX_AXES = 14 }; // 14 so that sizeof(PointerCoords) == 64
 
163
 
 
164
    // Bitfield of axes that are present in this structure.
 
165
    uint64_t bits;
 
166
 
 
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
 
 
175
    float getAxisValue(int32_t axis) const;
 
176
    status_t setAxisValue(int32_t axis, float value);
 
177
 
 
178
    void scale(float scale);
 
179
 
 
180
    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
 
 
188
#ifdef HAVE_ANDROID_OS
 
189
    status_t readFromParcel(Parcel* parcel);
 
190
    status_t writeToParcel(Parcel* parcel) const;
 
191
#endif
 
192
 
 
193
    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
 
 
200
private:
 
201
    void tooManyAxes(int axis);
 
202
};
 
203
 
 
204
/*
 
205
 * Pointer property data.
 
206
 */
 
207
struct 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
/*
 
228
 * Input events.
 
229
 */
 
230
class InputEvent : public AInputEvent {
 
231
public:
 
232
    virtual ~InputEvent() { }
 
233
 
 
234
    virtual int32_t getType() const = 0;
 
235
 
 
236
    inline int32_t getDeviceId() const { return mDeviceId; }
 
237
 
 
238
    inline int32_t getSource() const { return mSource; }
 
239
 
 
240
    inline void setSource(int32_t source) { mSource = source; }
 
241
 
 
242
protected:
 
243
    void initialize(int32_t deviceId, int32_t source);
 
244
    void initialize(const InputEvent& from);
 
245
 
 
246
    int32_t mDeviceId;
 
247
    int32_t mSource;
 
248
};
 
249
 
 
250
/*
 
251
 * Key events.
 
252
 */
 
253
class KeyEvent : public InputEvent {
 
254
public:
 
255
    virtual ~KeyEvent() { }
 
256
 
 
257
    virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }
 
258
 
 
259
    inline int32_t getAction() const { return mAction; }
 
260
 
 
261
    inline int32_t getFlags() const { return mFlags; }
 
262
 
 
263
    inline void setFlags(int32_t flags) { mFlags = flags; }
 
264
 
 
265
    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
 
 
277
    // 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
    
 
285
    void initialize(
 
286
            int32_t deviceId,
 
287
            int32_t source,
 
288
            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);
 
296
    void initialize(const KeyEvent& from);
 
297
 
 
298
protected:
 
299
    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
 
 
309
/*
 
310
 * Motion events.
 
311
 */
 
312
class MotionEvent : public InputEvent {
 
313
public:
 
314
    virtual ~MotionEvent() { }
 
315
 
 
316
    virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }
 
317
 
 
318
    inline int32_t getAction() const { return mAction; }
 
319
 
 
320
    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
 
 
327
    inline void setAction(int32_t action) { mAction = action; }
 
328
 
 
329
    inline int32_t getFlags() const { return mFlags; }
 
330
 
 
331
    inline void setFlags(int32_t flags) { mFlags = flags; }
 
332
 
 
333
    inline int32_t getEdgeFlags() const { return mEdgeFlags; }
 
334
 
 
335
    inline void setEdgeFlags(int32_t edgeFlags) { mEdgeFlags = edgeFlags; }
 
336
 
 
337
    inline int32_t getMetaState() const { return mMetaState; }
 
338
 
 
339
    inline void setMetaState(int32_t metaState) { mMetaState = metaState; }
 
340
 
 
341
    inline int32_t getButtonState() const { return mButtonState; }
 
342
 
 
343
    inline float getXOffset() const { return mXOffset; }
 
344
 
 
345
    inline float getYOffset() const { return mYOffset; }
 
346
 
 
347
    inline float getXPrecision() const { return mXPrecision; }
 
348
 
 
349
    inline float getYPrecision() const { return mYPrecision; }
 
350
 
 
351
    inline nsecs_t getDownTime() const { return mDownTime; }
 
352
 
 
353
    inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
 
354
 
 
355
    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
    }
 
368
 
 
369
    inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
 
370
 
 
371
    const PointerCoords* getRawPointerCoords(size_t pointerIndex) const;
 
372
 
 
373
    float getRawAxisValue(int32_t axis, size_t pointerIndex) const;
 
374
 
 
375
    inline float getRawX(size_t pointerIndex) const {
 
376
        return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
 
377
    }
 
378
 
 
379
    inline float getRawY(size_t pointerIndex) const {
 
380
        return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
 
381
    }
 
382
 
 
383
    float getAxisValue(int32_t axis, size_t pointerIndex) const;
 
384
 
 
385
    inline float getX(size_t pointerIndex) const {
 
386
        return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
 
387
    }
 
388
 
 
389
    inline float getY(size_t pointerIndex) const {
 
390
        return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
 
391
    }
 
392
 
 
393
    inline float getPressure(size_t pointerIndex) const {
 
394
        return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex);
 
395
    }
 
396
 
 
397
    inline float getSize(size_t pointerIndex) const {
 
398
        return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex);
 
399
    }
 
400
 
 
401
    inline float getTouchMajor(size_t pointerIndex) const {
 
402
        return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex);
 
403
    }
 
404
 
 
405
    inline float getTouchMinor(size_t pointerIndex) const {
 
406
        return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex);
 
407
    }
 
408
 
 
409
    inline float getToolMajor(size_t pointerIndex) const {
 
410
        return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex);
 
411
    }
 
412
 
 
413
    inline float getToolMinor(size_t pointerIndex) const {
 
414
        return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex);
 
415
    }
 
416
 
 
417
    inline float getOrientation(size_t pointerIndex) const {
 
418
        return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex);
 
419
    }
 
420
 
 
421
    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
 
 
427
    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
 
 
433
    inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const {
 
434
        return getHistoricalRawAxisValue(
 
435
                AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
 
436
    }
 
437
 
 
438
    inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const {
 
439
        return getHistoricalRawAxisValue(
 
440
                AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
 
441
    }
 
442
 
 
443
    float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const;
 
444
 
 
445
    inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const {
 
446
        return getHistoricalAxisValue(
 
447
                AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
 
448
    }
 
449
 
 
450
    inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const {
 
451
        return getHistoricalAxisValue(
 
452
                AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
 
453
    }
 
454
 
 
455
    inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const {
 
456
        return getHistoricalAxisValue(
 
457
                AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex);
 
458
    }
 
459
 
 
460
    inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const {
 
461
        return getHistoricalAxisValue(
 
462
                AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex);
 
463
    }
 
464
 
 
465
    inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const {
 
466
        return getHistoricalAxisValue(
 
467
                AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
 
468
    }
 
469
 
 
470
    inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const {
 
471
        return getHistoricalAxisValue(
 
472
                AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
 
473
    }
 
474
 
 
475
    inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const {
 
476
        return getHistoricalAxisValue(
 
477
                AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
 
478
    }
 
479
 
 
480
    inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const {
 
481
        return getHistoricalAxisValue(
 
482
                AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
 
483
    }
 
484
 
 
485
    inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const {
 
486
        return getHistoricalAxisValue(
 
487
                AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex);
 
488
    }
 
489
 
 
490
    ssize_t findPointerIndex(int32_t pointerId) const;
 
491
 
 
492
    void initialize(
 
493
            int32_t deviceId,
 
494
            int32_t source,
 
495
            int32_t action,
 
496
            int32_t flags,
 
497
            int32_t edgeFlags,
 
498
            int32_t metaState,
 
499
            int32_t buttonState,
 
500
            float xOffset,
 
501
            float yOffset,
 
502
            float xPrecision,
 
503
            float yPrecision,
 
504
            nsecs_t downTime,
 
505
            nsecs_t eventTime,
 
506
            size_t pointerCount,
 
507
            const PointerProperties* pointerProperties,
 
508
            const PointerCoords* pointerCoords);
 
509
 
 
510
    void copyFrom(const MotionEvent* other, bool keepHistory);
 
511
 
 
512
    void addSample(
 
513
            nsecs_t eventTime,
 
514
            const PointerCoords* pointerCoords);
 
515
 
 
516
    void offsetLocation(float xOffset, float yOffset);
 
517
 
 
518
    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
 
 
527
    static bool isTouchEvent(int32_t source, int32_t action);
 
528
    inline bool isTouchEvent() const {
 
529
        return isTouchEvent(mSource, mAction);
 
530
    }
 
531
 
 
532
    // Low-level accessors.
 
533
    inline const PointerProperties* getPointerProperties() const {
 
534
        return mPointerProperties.array();
 
535
    }
 
536
    inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
 
537
    inline const PointerCoords* getSamplePointerCoords() const {
 
538
            return mSamplePointerCoords.array();
 
539
    }
 
540
 
 
541
protected:
 
542
    int32_t mAction;
 
543
    int32_t mFlags;
 
544
    int32_t mEdgeFlags;
 
545
    int32_t mMetaState;
 
546
    int32_t mButtonState;
 
547
    float mXOffset;
 
548
    float mYOffset;
 
549
    float mXPrecision;
 
550
    float mYPrecision;
 
551
    nsecs_t mDownTime;
 
552
    Vector<PointerProperties> mPointerProperties;
 
553
    Vector<nsecs_t> mSampleEventTimes;
 
554
    Vector<PointerCoords> mSamplePointerCoords;
 
555
};
 
556
 
 
557
/*
 
558
 * Input event factory.
 
559
 */
 
560
class InputEventFactoryInterface {
 
561
protected:
 
562
    virtual ~InputEventFactoryInterface() { }
 
563
 
 
564
public:
 
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
 */
 
575
class PreallocatedInputEventFactory : public InputEventFactoryInterface {
 
576
public:
 
577
    PreallocatedInputEventFactory() { }
 
578
    virtual ~PreallocatedInputEventFactory() { }
 
579
 
 
580
    virtual KeyEvent* createKeyEvent() { return & mKeyEvent; }
 
581
    virtual MotionEvent* createMotionEvent() { return & mMotionEvent; }
 
582
 
 
583
private:
 
584
    KeyEvent mKeyEvent;
 
585
    MotionEvent mMotionEvent;
 
586
};
 
587
 
 
588
/*
 
589
 * An input event factory implementation that maintains a pool of input events.
 
590
 */
 
591
class PooledInputEventFactory : public InputEventFactoryInterface {
 
592
public:
 
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
 
 
601
private:
 
602
    const size_t mMaxPoolSize;
 
603
 
 
604
    Vector<KeyEvent*> mKeyEventPool;
 
605
    Vector<MotionEvent*> mMotionEventPool;
 
606
};
 
607
 
 
608
} // namespace android
 
609
 
 
610
#endif // _ANDROIDFW_INPUT_H