1
=== modified file '3rd_party/CMakeLists.txt'
2
--- 3rd_party/CMakeLists.txt	2015-06-17 05:20:42 +0000
3
+++ 3rd_party/CMakeLists.txt	2015-12-16 17:01:34 +0000
4
@@ -21,11 +21,3 @@
5
21
  MIR_ANDROID_INPUT_COMPILE_FLAGS
21
  MIR_ANDROID_INPUT_COMPILE_FLAGS
6
22
  ${MIR_ANDROID_INPUT_COMPILE_FLAGS}
22
  ${MIR_ANDROID_INPUT_COMPILE_FLAGS}
7
23
  PARENT_SCOPE)
23
  PARENT_SCOPE)
8
24
9
25
add_subdirectory(xcursor)
10
26
list(
11
27
  APPEND MIR_XCURSOR_INCLUDE_DIRECTORIES
12
28
  ${CMAKE_CURRENT_SOURCE_DIR}/xcursor/
13
29
)
14
30
15
31
set(MIR_XCURSOR_INCLUDE_DIRECTORIES ${MIR_XCURSOR_INCLUDE_DIRECTORIES} PARENT_SCOPE)
16
32
24
17
=== modified file '3rd_party/android-input/CMakeLists.txt'
18
--- 3rd_party/android-input/CMakeLists.txt	2015-02-22 07:46:25 +0000
19
+++ 3rd_party/android-input/CMakeLists.txt	2015-12-16 17:01:34 +0000
20
@@ -24,6 +24,6 @@
21
24
  ${CMAKE_CURRENT_SOURCE_DIR}/android/hardware/libhardware_legacy/include
24
  ${CMAKE_CURRENT_SOURCE_DIR}/android/hardware/libhardware_legacy/include
22
25
  ${CMAKE_CURRENT_SOURCE_DIR}/android/system/core/include
25
  ${CMAKE_CURRENT_SOURCE_DIR}/android/system/core/include
23
26
  ${CMAKE_CURRENT_SOURCE_DIR}/android/system/extras/ext4_utils
26
  ${CMAKE_CURRENT_SOURCE_DIR}/android/system/extras/ext4_utils
25
27
  ${CMAKE_CURRENT_SOURCE_DIR}/android/external/kernel-headers/original
27
  ${CMAKE_CURRENT_SOURCE_DIR}/android/external/kernel-headers
26
28
  )
28
  )
27
29
set(MIR_ANDROID_INCLUDE_DIRECTORIES ${MIR_ANDROID_INCLUDE_DIRECTORIES} PARENT_SCOPE)
29
set(MIR_ANDROID_INCLUDE_DIRECTORIES ${MIR_ANDROID_INCLUDE_DIRECTORIES} PARENT_SCOPE)
28
30
30
29
=== modified file '3rd_party/android-input/android/CMakeLists.txt'
30
--- 3rd_party/android-input/android/CMakeLists.txt	2015-08-19 02:03:51 +0000
31
+++ 3rd_party/android-input/android/CMakeLists.txt	2015-12-16 17:01:34 +0000
32
@@ -1,5 +1,5 @@
33
1
include_directories(
1
include_directories(
35
2
  external/kernel-headers/original
2
  external/kernel-headers
36
3
  frameworks/base/include
3
  frameworks/base/include
37
4
  frameworks/native/include
4
  frameworks/native/include
38
5
  hardware/libhardware_legacy/include
5
  hardware/libhardware_legacy/include
39
@@ -23,30 +23,8 @@
40
23
  frameworks/native/libs/utils/Timers.cpp     # used by KeyCharacterMap.cpp, InputReader.cpp, InputDispatcher.cpp, Looper.cpp
23
  frameworks/native/libs/utils/Timers.cpp     # used by KeyCharacterMap.cpp, InputReader.cpp, InputDispatcher.cpp, Looper.cpp
41
24
)
24
)
42
25
25
43
26
add_library(android-input-platform OBJECT
44
27
  frameworks/base/services/input/EventHub.cpp
45
28
  frameworks/base/services/input/InputDevice.cpp
46
29
  frameworks/base/services/input/InputListener.cpp
47
30
  frameworks/base/services/input/InputReader.cpp
48
31
  frameworks/base/services/input/GenericKeyMap.cpp
49
32
  frameworks/base/services/input/Keyboard.cpp
50
33
  frameworks/base/services/input/KeyCharacterMap.cpp
51
34
  frameworks/base/services/input/KeyLayoutMap.cpp
52
35
  frameworks/native/libs/utils/Tokenizer.cpp
53
36
  frameworks/base/services/input/VelocityControl.cpp
54
37
  frameworks/base/services/input/VelocityTracker.cpp
55
38
  frameworks/base/services/input/VirtualKeyMap.cpp
56
39
  frameworks/native/libs/utils/FileMap.cpp
57
40
)
58
41
59
42
set_target_properties(
26
set_target_properties(
60
43
  android-input-common
27
  android-input-common
61
44
  PROPERTIES
28
  PROPERTIES
62
45
  COMPILE_FLAGS ${ANDROID_INPUT_COMPILE_FLAGS}
29
  COMPILE_FLAGS ${ANDROID_INPUT_COMPILE_FLAGS}
63
46
)
30
)
64
47
65
48
set_target_properties(
66
49
  android-input-platform
67
50
  PROPERTIES
68
51
  COMPILE_FLAGS ${ANDROID_INPUT_COMPILE_FLAGS}
69
52
)
70
53
31
71
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/InputDevice.h'
72
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/InputDevice.h	2013-05-03 16:38:07 +0000
73
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/InputDevice.h	1970-01-01 00:00:00 +0000
74
@@ -1,156 +0,0 @@
75
1
/*
76
2
 * Copyright (C) 2012 The Android Open Source Project
77
3
 *
78
4
 * Licensed under the Apache License, Version 2.0 (the "License");
79
5
 * you may not use this file except in compliance with the License.
80
6
 * You may obtain a copy of the License at
81
7
 *
82
8
 *      http://www.apache.org/licenses/LICENSE-2.0
83
9
 *
84
10
 * Unless required by applicable law or agreed to in writing, software
85
11
 * distributed under the License is distributed on an "AS IS" BASIS,
86
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
87
13
 * See the License for the specific language governing permissions and
88
14
 * limitations under the License.
89
15
 */
90
16
91
17
#ifndef _ANDROIDFW_INPUT_DEVICE_H
92
18
#define _ANDROIDFW_INPUT_DEVICE_H
93
19
94
20
95
21
#include <androidfw/Input.h>
96
22
#include <androidfw/KeyCharacterMap.h>
97
23
98
24
namespace android {
99
25
100
26
/*
101
27
 * Identifies a device.
102
28
 */
103
29
struct InputDeviceIdentifier {
104
30
    inline InputDeviceIdentifier() :
105
31
            bus(0), vendor(0), product(0), version(0) {
106
32
    }
107
33
108
34
    // Information provided by the kernel.
109
35
    String8 name;
110
36
    String8 location;
111
37
    String8 uniqueId;
112
38
    uint16_t bus;
113
39
    uint16_t vendor;
114
40
    uint16_t product;
115
41
    uint16_t version;
116
42
117
43
    // A composite input device descriptor string that uniquely identifies the device
118
44
    // even across reboots or reconnections.  The value of this field is used by
119
45
    // upper layers of the input system to associate settings with individual devices.
120
46
    // It is hashed from whatever kernel provided information is available.
121
47
    // Ideally, the way this value is computed should not change between Android releases
122
48
    // because that would invalidate persistent settings that rely on it.
123
49
    String8 descriptor;
124
50
};
125
51
126
52
/*
127
53
 * Describes the characteristics and capabilities of an input device.
128
54
 */
129
55
class InputDeviceInfo {
130
56
public:
131
57
    InputDeviceInfo();
132
58
    InputDeviceInfo(const InputDeviceInfo& other);
133
59
    ~InputDeviceInfo();
134
60
135
61
    struct MotionRange {
136
62
        int32_t axis;
137
63
        uint32_t source;
138
64
        float min;
139
65
        float max;
140
66
        float flat;
141
67
        float fuzz;
142
68
    };
143
69
144
70
    void initialize(int32_t id, int32_t generation, const InputDeviceIdentifier& identifier,
145
71
            const String8& alias, bool isExternal);
146
72
147
73
    inline int32_t getId() const { return mId; }
148
74
    inline int32_t getGeneration() const { return mGeneration; }
149
75
    inline const InputDeviceIdentifier& getIdentifier() const { return mIdentifier; }
150
76
    inline const String8& getAlias() const { return mAlias; }
151
77
    inline const String8& getDisplayName() const {
152
78
        return isEmpty(mAlias) ? mIdentifier.name : mAlias;
153
79
    }
154
80
    inline bool isExternal() const { return mIsExternal; }
155
81
    inline uint32_t getSources() const { return mSources; }
156
82
157
83
    const MotionRange* getMotionRange(int32_t axis, uint32_t source) const;
158
84
159
85
    void addSource(uint32_t source);
160
86
    void addMotionRange(int32_t axis, uint32_t source,
161
87
            float min, float max, float flat, float fuzz);
162
88
    void addMotionRange(const MotionRange& range);
163
89
164
90
    inline void setKeyboardType(int32_t keyboardType) { mKeyboardType = keyboardType; }
165
91
    inline int32_t getKeyboardType() const { return mKeyboardType; }
166
92
167
93
    inline void setKeyCharacterMap(const sp<KeyCharacterMap>& value) {
168
94
        mKeyCharacterMap = value;
169
95
    }
170
96
171
97
    inline sp<KeyCharacterMap> getKeyCharacterMap() const {
172
98
        return mKeyCharacterMap;
173
99
    }
174
100
175
101
    inline void setVibrator(bool hasVibrator) { mHasVibrator = hasVibrator; }
176
102
    inline bool hasVibrator() const { return mHasVibrator; }
177
103
178
104
    inline const Vector<MotionRange>& getMotionRanges() const {
179
105
        return mMotionRanges;
180
106
    }
181
107
182
108
private:
183
109
    int32_t mId;
184
110
    int32_t mGeneration;
185
111
    InputDeviceIdentifier mIdentifier;
186
112
    String8 mAlias;
187
113
    bool mIsExternal;
188
114
    uint32_t mSources;
189
115
    int32_t mKeyboardType;
190
116
    sp<KeyCharacterMap> mKeyCharacterMap;
191
117
    bool mHasVibrator;
192
118
193
119
    Vector<MotionRange> mMotionRanges;
194
120
};
195
121
196
122
/* Types of input device configuration files. */
197
123
enum InputDeviceConfigurationFileType {
198
124
    INPUT_DEVICE_CONFIGURATION_FILE_TYPE_CONFIGURATION = 0,     /* .idc file */
199
125
    INPUT_DEVICE_CONFIGURATION_FILE_TYPE_KEY_LAYOUT = 1,        /* .kl file */
200
126
    INPUT_DEVICE_CONFIGURATION_FILE_TYPE_KEY_CHARACTER_MAP = 2 /* .kcm file */
201
127
};
202
128
203
129
/*
204
130
 * Gets the path of an input device configuration file, if one is available.
205
131
 * Considers both system provided and user installed configuration files.
206
132
 *
207
133
 * The device identifier is used to construct several default configuration file
208
134
 * names to try based on the device name, vendor, product, and version.
209
135
 *
210
136
 * Returns an empty string if not found.
211
137
 */
212
138
extern String8 getInputDeviceConfigurationFilePathByDeviceIdentifier(
213
139
        const InputDeviceIdentifier& deviceIdentifier,
214
140
        InputDeviceConfigurationFileType type);
215
141
216
142
/*
217
143
 * Gets the path of an input device configuration file, if one is available.
218
144
 * Considers both system provided and user installed configuration files.
219
145
 *
220
146
 * The name is case-sensitive and is used to construct the filename to resolve.
221
147
 * All characters except 'a'-'z', 'A'-'Z', '0'-'9', '-', and '_' are replaced by underscores.
222
148
 *
223
149
 * Returns an empty string if not found.
224
150
 */
225
151
extern String8 getInputDeviceConfigurationFilePathByName(
226
152
        const String8& name, InputDeviceConfigurationFileType type);
227
153
228
154
} // namespace android
229
155
230
156
#endif // _ANDROIDFW_INPUT_DEVICE_H
231
157
0
232
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h'
233
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h	2015-04-28 07:54:10 +0000
234
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyCharacterMap.h	1970-01-01 00:00:00 +0000
235
@@ -1,255 +0,0 @@
236
1
/*
237
2
 * Copyright (C) 2008 The Android Open Source Project
238
3
 *
239
4
 * Licensed under the Apache License, Version 2.0 (the "License");
240
5
 * you may not use this file except in compliance with the License.
241
6
 * You may obtain a copy of the License at
242
7
 *
243
8
 *      http://www.apache.org/licenses/LICENSE-2.0
244
9
 *
245
10
 * Unless required by applicable law or agreed to in writing, software
246
11
 * distributed under the License is distributed on an "AS IS" BASIS,
247
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
248
13
 * See the License for the specific language governing permissions and
249
14
 * limitations under the License.
250
15
 */
251
16
252
17
#ifndef _ANDROIDFW_KEY_CHARACTER_MAP_H
253
18
#define _ANDROIDFW_KEY_CHARACTER_MAP_H
254
19
255
20
256
21
#include <stdint.h>
257
22
258
23
#if HAVE_ANDROID_OS
259
24
#include <binder/IBinder.h>
260
25
#endif
261
26
262
27
#include <androidfw/Input.h>
263
28
#include <std/Errors.h>
264
29
#include <std/KeyedVector.h>
265
30
#include <std/Tokenizer.h>
266
31
#include <std/String8.h>
267
32
#include <std/RefBase.h>
268
33
269
34
namespace android {
270
35
271
36
/**
272
37
 * Describes a mapping from Android key codes to characters.
273
38
 * Also specifies other functions of the keyboard such as the keyboard type
274
39
 * and key modifier semantics.
275
40
 *
276
41
 * This object is immutable after it has been loaded.
277
42
 */
278
43
class KeyCharacterMap : public RefBase {
279
44
public:
280
45
    enum KeyboardType {
281
46
        KEYBOARD_TYPE_UNKNOWN = 0,
282
47
        KEYBOARD_TYPE_NUMERIC = 1,
283
48
        KEYBOARD_TYPE_PREDICTIVE = 2,
284
49
        KEYBOARD_TYPE_ALPHA = 3,
285
50
        KEYBOARD_TYPE_FULL = 4,
286
51
        KEYBOARD_TYPE_SPECIAL_FUNCTION = 5,
287
52
        KEYBOARD_TYPE_OVERLAY = 6
288
53
    };
289
54
290
55
    enum Format {
291
56
        // Base keyboard layout, may contain device-specific options, such as "type" declaration.
292
57
        FORMAT_BASE = 0,
293
58
        // Overlay keyboard layout, more restrictive, may be published by applications,
294
59
        // cannot override device-specific options.
295
60
        FORMAT_OVERLAY = 1,
296
61
        // Either base or overlay layout ok.
297
62
        FORMAT_ANY = 2
298
63
    };
299
64
300
65
    // Substitute key code and meta state for fallback action.
301
66
    struct FallbackAction {
302
67
        int32_t keyCode;
303
68
        int32_t metaState;
304
69
    };
305
70
306
71
    /* Loads a key character map from a file. */
307
72
    static status_t load(const String8& filename, Format format, sp<KeyCharacterMap>* outMap);
308
73
309
74
    /* Loads a key character map from its string contents. */
310
75
    static status_t loadContents(const String8& filename,
311
76
            const char* contents, Format format, sp<KeyCharacterMap>* outMap);
312
77
313
78
    /* Combines a base key character map and an overlay. */
314
79
    static sp<KeyCharacterMap> combine(const sp<KeyCharacterMap>& base,
315
80
            const sp<KeyCharacterMap>& overlay);
316
81
317
82
    /* Returns an empty key character map. */
318
83
    static sp<KeyCharacterMap> empty();
319
84
320
85
    /* Gets the keyboard type. */
321
86
    int32_t getKeyboardType() const;
322
87
323
88
    /* Gets the primary character for this key as in the label physically printed on it.
324
89
     * Returns 0 if none (eg. for non-printing keys). */
325
90
    char16_t getDisplayLabel(int32_t keyCode) const;
326
91
327
92
    /* Gets the Unicode character for the number or symbol generated by the key
328
93
     * when the keyboard is used as a dialing pad.
329
94
     * Returns 0 if no number or symbol is generated.
330
95
     */
331
96
    char16_t getNumber(int32_t keyCode) const;
332
97
333
98
    /* Gets the Unicode character generated by the key and meta key modifiers.
334
99
     * Returns 0 if no character is generated.
335
100
     */
336
101
    char16_t getCharacter(int32_t keyCode, int32_t metaState) const;
337
102
338
103
    /* Gets the fallback action to use by default if the application does not
339
104
     * handle the specified key.
340
105
     * Returns true if an action was available, false if none.
341
106
     */
342
107
    bool getFallbackAction(int32_t keyCode, int32_t metaState,
343
108
            FallbackAction* outFallbackAction) const;
344
109
345
110
    /* Gets the first matching Unicode character that can be generated by the key,
346
111
     * preferring the one with the specified meta key modifiers.
347
112
     * Returns 0 if no matching character is generated.
348
113
     */
349
114
    char16_t getMatch(int32_t keyCode, const char16_t* chars,
350
115
            size_t numChars, int32_t metaState) const;
351
116
352
117
    /* Gets a sequence of key events that could plausibly generate the specified
353
118
     * character sequence.  Returns false if some of the characters cannot be generated.
354
119
     */
355
120
    bool getEvents(int32_t deviceId, const char16_t* chars, size_t numChars,
356
121
            Vector<KeyEvent>& outEvents) const;
357
122
358
123
    /* Maps a scan code and usage code to a key code, in case this key map overrides
359
124
     * the mapping in some way. */
360
125
    status_t mapKey(int32_t scanCode, int32_t usageCode, int32_t* outKeyCode) const;
361
126
362
127
#if HAVE_ANDROID_OS
363
128
    /* Reads a key map from a parcel. */
364
129
    static sp<KeyCharacterMap> readFromParcel(Parcel* parcel);
365
130
366
131
    /* Writes a key map to a parcel. */
367
132
    void writeToParcel(Parcel* parcel) const;
368
133
#endif
369
134
370
135
protected:
371
136
    virtual ~KeyCharacterMap();
372
137
373
138
private:
374
139
    struct Behavior {
375
140
        Behavior();
376
141
        Behavior(const Behavior& other);
377
142
378
143
        /* The next behavior in the list, or NULL if none. */
379
144
        Behavior* next;
380
145
381
146
        /* The meta key modifiers for this behavior. */
382
147
        int32_t metaState;
383
148
384
149
        /* The character to insert. */
385
150
        char16_t character;
386
151
387
152
        /* The fallback keycode if the key is not handled. */
388
153
        int32_t fallbackKeyCode;
389
154
    };
390
155
391
156
    struct Key {
392
157
        Key();
393
158
        Key(const Key& other);
394
159
        ~Key();
395
160
396
161
        /* The single character label printed on the key, or 0 if none. */
397
162
        char16_t label;
398
163
399
164
        /* The number or symbol character generated by the key, or 0 if none. */
400
165
        char16_t number;
401
166
402
167
        /* The list of key behaviors sorted from most specific to least specific
403
168
         * meta key binding. */
404
169
        Behavior* firstBehavior;
405
170
    };
406
171
407
172
    class Parser {
408
173
        enum State {
409
174
            STATE_TOP = 0,
410
175
            STATE_KEY = 1
411
176
        };
412
177
413
178
        enum {
414
179
            PROPERTY_LABEL = 1,
415
180
            PROPERTY_NUMBER = 2,
416
181
            PROPERTY_META = 3
417
182
        };
418
183
419
184
        struct Property {
420
185
            inline Property(int32_t property = 0, int32_t metaState = 0) :
421
186
                    property(property), metaState(metaState) { }
422
187
423
188
            int32_t property;
424
189
            int32_t metaState;
425
190
        };
426
191
427
192
        KeyCharacterMap* mMap;
428
193
        Tokenizer* mTokenizer;
429
194
        Format mFormat;
430
195
        State mState;
431
196
        int32_t mKeyCode;
432
197
433
198
    public:
434
199
        Parser(KeyCharacterMap* map, Tokenizer* tokenizer, Format format);
435
200
        ~Parser();
436
201
        status_t parse();
437
202
438
203
    private:
439
204
        status_t parseType();
440
205
        status_t parseMap();
441
206
        status_t parseMapKey();
442
207
        status_t parseKey();
443
208
        status_t parseKeyProperty();
444
209
        status_t finishKey(Key* key);
445
210
        status_t parseModifier(const String8& token, int32_t* outMetaState);
446
211
        status_t parseCharacterLiteral(char16_t* outCharacter);
447
212
    };
448
213
449
214
    KeyedVector<int32_t, Key*> mKeys;
450
215
    int mType;
451
216
452
217
    KeyedVector<int32_t, int32_t> mKeysByScanCode;
453
218
    KeyedVector<int32_t, int32_t> mKeysByUsageCode;
454
219
455
220
    KeyCharacterMap();
456
221
    KeyCharacterMap(const KeyCharacterMap& other);
457
222
458
223
    bool getKey(int32_t keyCode, const Key** outKey) const;
459
224
    bool getKeyBehavior(int32_t keyCode, int32_t metaState,
460
225
            const Key** outKey, const Behavior** outBehavior) const;
461
226
    static bool matchesMetaState(int32_t eventMetaState, int32_t behaviorMetaState);
462
227
463
228
    bool findKey(char16_t ch, int32_t* outKeyCode, int32_t* outMetaState) const;
464
229
465
230
    static status_t load(Tokenizer* tokenizer, Format format, sp<KeyCharacterMap>* outMap);
466
231
467
232
    static void addKey(Vector<KeyEvent>& outEvents,
468
233
            int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, std::chrono::nanoseconds time);
469
234
    static void addMetaKeys(Vector<KeyEvent>& outEvents,
470
235
            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
471
236
            int32_t* currentMetaState);
472
237
    static bool addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
473
238
            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
474
239
            int32_t keyCode, int32_t keyMetaState,
475
240
            int32_t* currentMetaState);
476
241
    static void addDoubleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
477
242
            int32_t deviceId, int32_t metaState, bool down, std::chrono::nanoseconds time,
478
243
            int32_t leftKeyCode, int32_t leftKeyMetaState,
479
244
            int32_t rightKeyCode, int32_t rightKeyMetaState,
480
245
            int32_t eitherKeyMetaState,
481
246
            int32_t* currentMetaState);
482
247
    static void addLockedMetaKey(Vector<KeyEvent>& outEvents,
483
248
            int32_t deviceId, int32_t metaState, std::chrono::nanoseconds time,
484
249
            int32_t keyCode, int32_t keyMetaState,
485
250
            int32_t* currentMetaState);
486
251
};
487
252
488
253
} // namespace android
489
254
490
255
#endif // _ANDROIDFW_KEY_CHARACTER_MAP_H
491
256
0
492
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/KeyLayoutMap.h'
493
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyLayoutMap.h	2013-05-03 16:38:07 +0000
494
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/KeyLayoutMap.h	1970-01-01 00:00:00 +0000
495
@@ -1,114 +0,0 @@
496
1
/*
497
2
 * Copyright (C) 2008 The Android Open Source Project
498
3
 *
499
4
 * Licensed under the Apache License, Version 2.0 (the "License");
500
5
 * you may not use this file except in compliance with the License.
501
6
 * You may obtain a copy of the License at
502
7
 *
503
8
 *      http://www.apache.org/licenses/LICENSE-2.0
504
9
 *
505
10
 * Unless required by applicable law or agreed to in writing, software
506
11
 * distributed under the License is distributed on an "AS IS" BASIS,
507
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
508
13
 * See the License for the specific language governing permissions and
509
14
 * limitations under the License.
510
15
 */
511
16
512
17
#ifndef _ANDROIDFW_KEY_LAYOUT_MAP_H
513
18
#define _ANDROIDFW_KEY_LAYOUT_MAP_H
514
19
515
20
516
21
#include <stdint.h>
517
22
#include <std/Errors.h>
518
23
#include <std/KeyedVector.h>
519
24
#include <std/Tokenizer.h>
520
25
#include <std/RefBase.h>
521
26
522
27
namespace android {
523
28
524
29
struct AxisInfo {
525
30
    enum Mode {
526
31
        // Axis value is reported directly.
527
32
        MODE_NORMAL = 0,
528
33
        // Axis value should be inverted before reporting.
529
34
        MODE_INVERT = 1,
530
35
        // Axis value should be split into two axes
531
36
        MODE_SPLIT = 2
532
37
    };
533
38
534
39
    // Axis mode.
535
40
    Mode mode;
536
41
537
42
    // Axis id.
538
43
    // When split, this is the axis used for values smaller than the split position.
539
44
    int32_t axis;
540
45
541
46
    // When split, this is the axis used for values after higher than the split position.
542
47
    int32_t highAxis;
543
48
544
49
    // The split value, or 0 if not split.
545
50
    int32_t splitValue;
546
51
547
52
    // The flat value, or -1 if none.
548
53
    int32_t flatOverride;
549
54
550
55
    AxisInfo() : mode(MODE_NORMAL), axis(-1), highAxis(-1), splitValue(0), flatOverride(-1) {
551
56
    }
552
57
};
553
58
554
59
/**
555
60
 * Describes a mapping from keyboard scan codes and joystick axes to Android key codes and axes.
556
61
 *
557
62
 * This object is immutable after it has been loaded.
558
63
 */
559
64
class KeyLayoutMap : public RefBase {
560
65
public:
561
66
    static status_t load(const String8& filename, sp<KeyLayoutMap>* outMap);
562
67
    // <mir changes>
563
68
    static status_t load(const String8& filename, const char* contents, sp<KeyLayoutMap>* outMap);
564
69
    // </mir changes>
565
70
566
71
    status_t mapKey(int32_t scanCode, int32_t usageCode,
567
72
            int32_t* outKeyCode, uint32_t* outFlags) const;
568
73
    status_t findScanCodesForKey(int32_t keyCode, Vector<int32_t>* outScanCodes) const;
569
74
570
75
    status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const;
571
76
572
77
protected:
573
78
    virtual ~KeyLayoutMap();
574
79
575
80
private:
576
81
    // <mir changes>
577
82
    static status_t load(Tokenizer* tokenizer, sp<KeyLayoutMap>* outMap);
578
83
    // </mir changes>
579
84
    struct Key {
580
85
        int32_t keyCode;
581
86
        uint32_t flags;
582
87
    };
583
88
584
89
    KeyedVector<int32_t, Key> mKeysByScanCode;
585
90
    KeyedVector<int32_t, Key> mKeysByUsageCode;
586
91
    KeyedVector<int32_t, AxisInfo> mAxes;
587
92
588
93
    KeyLayoutMap();
589
94
590
95
    const Key* getKey(int32_t scanCode, int32_t usageCode) const;
591
96
592
97
    class Parser {
593
98
        KeyLayoutMap* mMap;
594
99
        Tokenizer* mTokenizer;
595
100
596
101
    public:
597
102
        Parser(KeyLayoutMap* map, Tokenizer* tokenizer);
598
103
        ~Parser();
599
104
        status_t parse();
600
105
601
106
    private:
602
107
        status_t parseKey();
603
108
        status_t parseAxis();
604
109
    };
605
110
};
606
111
607
112
} // namespace android
608
113
609
114
#endif // _ANDROIDFW_KEY_LAYOUT_MAP_H
610
115
0
611
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/Keyboard.h'
612
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/Keyboard.h	2013-05-03 16:38:07 +0000
613
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/Keyboard.h	1970-01-01 00:00:00 +0000
614
@@ -1,125 +0,0 @@
615
1
/*
616
2
 * Copyright (C) 2010 The Android Open Source Project
617
3
 *
618
4
 * Licensed under the Apache License, Version 2.0 (the "License");
619
5
 * you may not use this file except in compliance with the License.
620
6
 * You may obtain a copy of the License at
621
7
 *
622
8
 *      http://www.apache.org/licenses/LICENSE-2.0
623
9
 *
624
10
 * Unless required by applicable law or agreed to in writing, software
625
11
 * distributed under the License is distributed on an "AS IS" BASIS,
626
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
627
13
 * See the License for the specific language governing permissions and
628
14
 * limitations under the License.
629
15
 */
630
16
631
17
#ifndef _ANDROIDFW_KEYBOARD_H
632
18
#define _ANDROIDFW_KEYBOARD_H
633
19
634
20
635
21
#include <androidfw/Input.h>
636
22
#include <androidfw/InputDevice.h>
637
23
#include <std/Errors.h>
638
24
#include <std/String8.h>
639
25
#include <std/PropertyMap.h>
640
26
641
27
namespace android {
642
28
643
29
enum {
644
30
    /* Device id of the built in keyboard. */
645
31
    DEVICE_ID_BUILT_IN_KEYBOARD = 0,
646
32
647
33
    /* Device id of a generic virtual keyboard with a full layout that can be used
648
34
     * to synthesize key events. */
649
35
    DEVICE_ID_VIRTUAL_KEYBOARD = -1
650
36
};
651
37
652
38
class KeyLayoutMap;
653
39
class KeyCharacterMap;
654
40
655
41
/**
656
42
 * Loads the key layout map and key character map for a keyboard device.
657
43
 */
658
44
class KeyMap {
659
45
public:
660
46
    String8 keyLayoutFile;
661
47
    sp<KeyLayoutMap> keyLayoutMap;
662
48
663
49
    String8 keyCharacterMapFile;
664
50
    sp<KeyCharacterMap> keyCharacterMap;
665
51
666
52
    KeyMap();
667
53
    ~KeyMap();
668
54
669
55
    status_t load(const InputDeviceIdentifier& deviceIdenfier,
670
56
            const PropertyMap* deviceConfiguration);
671
57
672
58
    // <mir changes>
673
59
    status_t loadGenericMaps();
674
60
    // </mir changes>
675
61
676
62
    inline bool haveKeyLayout() const {
677
63
        return !isEmpty(keyLayoutFile);
678
64
    }
679
65
680
66
    inline bool haveKeyCharacterMap() const {
681
67
        return !isEmpty(keyCharacterMapFile);
682
68
    }
683
69
684
70
    inline bool isComplete() const {
685
71
        return haveKeyLayout() && haveKeyCharacterMap();
686
72
    }
687
73
688
74
private:
689
75
    bool probeKeyMap(const InputDeviceIdentifier& deviceIdentifier, const String8& name);
690
76
    status_t loadKeyLayout(const InputDeviceIdentifier& deviceIdentifier, const String8& name);
691
77
    status_t loadKeyCharacterMap(const InputDeviceIdentifier& deviceIdentifier,
692
78
            const String8& name);
693
79
    String8 getPath(const InputDeviceIdentifier& deviceIdentifier,
694
80
            const String8& name, InputDeviceConfigurationFileType type);
695
81
};
696
82
697
83
/**
698
84
 * Returns true if the keyboard is eligible for use as a built-in keyboard.
699
85
 */
700
86
extern bool isEligibleBuiltInKeyboard(const InputDeviceIdentifier& deviceIdentifier,
701
87
        const PropertyMap* deviceConfiguration, const KeyMap* keyMap);
702
88
703
89
/**
704
90
 * Gets a key code by its short form label, eg. "HOME".
705
91
 * Returns 0 if unknown.
706
92
 */
707
93
extern int32_t getKeyCodeByLabel(const char* label);
708
94
709
95
/**
710
96
 * Gets a key flag by its short form label, eg. "WAKE".
711
97
 * Returns 0 if unknown.
712
98
 */
713
99
extern uint32_t getKeyFlagByLabel(const char* label);
714
100
715
101
/**
716
102
 * Gets a axis by its short form label, eg. "X".
717
103
 * Returns -1 if unknown.
718
104
 */
719
105
extern int32_t getAxisByLabel(const char* label);
720
106
721
107
/**
722
108
 * Gets a axis label by its id.
723
109
 * Returns NULL if unknown.
724
110
 */
725
111
extern const char* getAxisLabel(int32_t axisId);
726
112
727
113
/**
728
114
 * Updates a meta state field when a key is pressed or released.
729
115
 */
730
116
extern int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState);
731
117
732
118
/**
733
119
 * Returns true if a key is a meta key like ALT or CAPS_LOCK.
734
120
 */
735
121
extern bool isMetaKey(int32_t keyCode);
736
122
737
123
} // namespace android
738
124
739
125
#endif // _ANDROIDFW_KEYBOARD_H
740
126
0
741
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/KeycodeLabels.h'
742
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/KeycodeLabels.h	2013-05-03 16:38:07 +0000
743
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/KeycodeLabels.h	1970-01-01 00:00:00 +0000
744
@@ -1,320 +0,0 @@
745
1
/*
746
2
 * Copyright (C) 2008 The Android Open Source Project
747
3
 *
748
4
 * Licensed under the Apache License, Version 2.0 (the "License");
749
5
 * you may not use this file except in compliance with the License.
750
6
 * You may obtain a copy of the License at
751
7
 *
752
8
 *      http://www.apache.org/licenses/LICENSE-2.0
753
9
 *
754
10
 * Unless required by applicable law or agreed to in writing, software
755
11
 * distributed under the License is distributed on an "AS IS" BASIS,
756
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
757
13
 * See the License for the specific language governing permissions and
758
14
 * limitations under the License.
759
15
 */
760
16
761
17
#ifndef _ANDROIDFW_KEYCODE_LABELS_H
762
18
#define _ANDROIDFW_KEYCODE_LABELS_H
763
19
764
20
765
21
#include <android/keycodes.h>
766
22
767
23
struct KeycodeLabel {
768
24
    const char *literal;
769
25
    int value;
770
26
};
771
27
772
28
static const KeycodeLabel KEYCODES[] = {
773
29
    { "SOFT_LEFT", 1 },
774
30
    { "SOFT_RIGHT", 2 },
775
31
    { "HOME", 3 },
776
32
    { "BACK", 4 },
777
33
    { "CALL", 5 },
778
34
    { "ENDCALL", 6 },
779
35
    { "0", 7 },
780
36
    { "1", 8 },
781
37
    { "2", 9 },
782
38
    { "3", 10 },
783
39
    { "4", 11 },
784
40
    { "5", 12 },
785
41
    { "6", 13 },
786
42
    { "7", 14 },
787
43
    { "8", 15 },
788
44
    { "9", 16 },
789
45
    { "STAR", 17 },
790
46
    { "POUND", 18 },
791
47
    { "DPAD_UP", 19 },
792
48
    { "DPAD_DOWN", 20 },
793
49
    { "DPAD_LEFT", 21 },
794
50
    { "DPAD_RIGHT", 22 },
795
51
    { "DPAD_CENTER", 23 },
796
52
    { "VOLUME_UP", 24 },
797
53
    { "VOLUME_DOWN", 25 },
798
54
    { "POWER", 26 },
799
55
    { "CAMERA", 27 },
800
56
    { "CLEAR", 28 },
801
57
    { "A", 29 },
802
58
    { "B", 30 },
803
59
    { "C", 31 },
804
60
    { "D", 32 },
805
61
    { "E", 33 },
806
62
    { "F", 34 },
807
63
    { "G", 35 },
808
64
    { "H", 36 },
809
65
    { "I", 37 },
810
66
    { "J", 38 },
811
67
    { "K", 39 },
812
68
    { "L", 40 },
813
69
    { "M", 41 },
814
70
    { "N", 42 },
815
71
    { "O", 43 },
816
72
    { "P", 44 },
817
73
    { "Q", 45 },
818
74
    { "R", 46 },
819
75
    { "S", 47 },
820
76
    { "T", 48 },
821
77
    { "U", 49 },
822
78
    { "V", 50 },
823
79
    { "W", 51 },
824
80
    { "X", 52 },
825
81
    { "Y", 53 },
826
82
    { "Z", 54 },
827
83
    { "COMMA", 55 },
828
84
    { "PERIOD", 56 },
829
85
    { "ALT_LEFT", 57 },
830
86
    { "ALT_RIGHT", 58 },
831
87
    { "SHIFT_LEFT", 59 },
832
88
    { "SHIFT_RIGHT", 60 },
833
89
    { "TAB", 61 },
834
90
    { "SPACE", 62 },
835
91
    { "SYM", 63 },
836
92
    { "EXPLORER", 64 },
837
93
    { "ENVELOPE", 65 },
838
94
    { "ENTER", 66 },
839
95
    { "DEL", 67 },
840
96
    { "GRAVE", 68 },
841
97
    { "MINUS", 69 },
842
98
    { "EQUALS", 70 },
843
99
    { "LEFT_BRACKET", 71 },
844
100
    { "RIGHT_BRACKET", 72 },
845
101
    { "BACKSLASH", 73 },
846
102
    { "SEMICOLON", 74 },
847
103
    { "APOSTROPHE", 75 },
848
104
    { "SLASH", 76 },
849
105
    { "AT", 77 },
850
106
    { "NUM", 78 },
851
107
    { "HEADSETHOOK", 79 },
852
108
    { "FOCUS", 80 },
853
109
    { "PLUS", 81 },
854
110
    { "MENU", 82 },
855
111
    { "NOTIFICATION", 83 },
856
112
    { "SEARCH", 84 },
857
113
    { "MEDIA_PLAY_PAUSE", 85 },
858
114
    { "MEDIA_STOP", 86 },
859
115
    { "MEDIA_NEXT", 87 },
860
116
    { "MEDIA_PREVIOUS", 88 },
861
117
    { "MEDIA_REWIND", 89 },
862
118
    { "MEDIA_FAST_FORWARD", 90 },
863
119
    { "MUTE", 91 },
864
120
    { "PAGE_UP", 92 },
865
121
    { "PAGE_DOWN", 93 },
866
122
    { "PICTSYMBOLS", 94 },
867
123
    { "SWITCH_CHARSET", 95 },
868
124
    { "BUTTON_A", 96 },
869
125
    { "BUTTON_B", 97 },
870
126
    { "BUTTON_C", 98 },
871
127
    { "BUTTON_X", 99 },
872
128
    { "BUTTON_Y", 100 },
873
129
    { "BUTTON_Z", 101 },
874
130
    { "BUTTON_L1", 102 },
875
131
    { "BUTTON_R1", 103 },
876
132
    { "BUTTON_L2", 104 },
877
133
    { "BUTTON_R2", 105 },
878
134
    { "BUTTON_THUMBL", 106 },
879
135
    { "BUTTON_THUMBR", 107 },
880
136
    { "BUTTON_START", 108 },
881
137
    { "BUTTON_SELECT", 109 },
882
138
    { "BUTTON_MODE", 110 },
883
139
    { "ESCAPE", 111 },
884
140
    { "FORWARD_DEL", 112 },
885
141
    { "CTRL_LEFT", 113 },
886
142
    { "CTRL_RIGHT", 114 },
887
143
    { "CAPS_LOCK", 115 },
888
144
    { "SCROLL_LOCK", 116 },
889
145
    { "META_LEFT", 117 },
890
146
    { "META_RIGHT", 118 },
891
147
    { "FUNCTION", 119 },
892
148
    { "SYSRQ", 120 },
893
149
    { "BREAK", 121 },
894
150
    { "MOVE_HOME", 122 },
895
151
    { "MOVE_END", 123 },
896
152
    { "INSERT", 124 },
897
153
    { "FORWARD", 125 },
898
154
    { "MEDIA_PLAY", 126 },
899
155
    { "MEDIA_PAUSE", 127 },
900
156
    { "MEDIA_CLOSE", 128 },
901
157
    { "MEDIA_EJECT", 129 },
902
158
    { "MEDIA_RECORD", 130 },
903
159
    { "F1", 131 },
904
160
    { "F2", 132 },
905
161
    { "F3", 133 },
906
162
    { "F4", 134 },
907
163
    { "F5", 135 },
908
164
    { "F6", 136 },
909
165
    { "F7", 137 },
910
166
    { "F8", 138 },
911
167
    { "F9", 139 },
912
168
    { "F10", 140 },
913
169
    { "F11", 141 },
914
170
    { "F12", 142 },
915
171
    { "NUM_LOCK", 143 },
916
172
    { "NUMPAD_0", 144 },
917
173
    { "NUMPAD_1", 145 },
918
174
    { "NUMPAD_2", 146 },
919
175
    { "NUMPAD_3", 147 },
920
176
    { "NUMPAD_4", 148 },
921
177
    { "NUMPAD_5", 149 },
922
178
    { "NUMPAD_6", 150 },
923
179
    { "NUMPAD_7", 151 },
924
180
    { "NUMPAD_8", 152 },
925
181
    { "NUMPAD_9", 153 },
926
182
    { "NUMPAD_DIVIDE", 154 },
927
183
    { "NUMPAD_MULTIPLY", 155 },
928
184
    { "NUMPAD_SUBTRACT", 156 },
929
185
    { "NUMPAD_ADD", 157 },
930
186
    { "NUMPAD_DOT", 158 },
931
187
    { "NUMPAD_COMMA", 159 },
932
188
    { "NUMPAD_ENTER", 160 },
933
189
    { "NUMPAD_EQUALS", 161 },
934
190
    { "NUMPAD_LEFT_PAREN", 162 },
935
191
    { "NUMPAD_RIGHT_PAREN", 163 },
936
192
    { "VOLUME_MUTE", 164 },
937
193
    { "INFO", 165 },
938
194
    { "CHANNEL_UP", 166 },
939
195
    { "CHANNEL_DOWN", 167 },
940
196
    { "ZOOM_IN", 168 },
941
197
    { "ZOOM_OUT", 169 },
942
198
    { "TV", 170 },
943
199
    { "WINDOW", 171 },
944
200
    { "GUIDE", 172 },
945
201
    { "DVR", 173 },
946
202
    { "BOOKMARK", 174 },
947
203
    { "CAPTIONS", 175 },
948
204
    { "SETTINGS", 176 },
949
205
    { "TV_POWER", 177 },
950
206
    { "TV_INPUT", 178 },
951
207
    { "STB_POWER", 179 },
952
208
    { "STB_INPUT", 180 },
953
209
    { "AVR_POWER", 181 },
954
210
    { "AVR_INPUT", 182 },
955
211
    { "PROG_RED", 183 },
956
212
    { "PROG_GREEN", 184 },
957
213
    { "PROG_YELLOW", 185 },
958
214
    { "PROG_BLUE", 186 },
959
215
    { "APP_SWITCH", 187 },
960
216
    { "BUTTON_1", 188 },
961
217
    { "BUTTON_2", 189 },
962
218
    { "BUTTON_3", 190 },
963
219
    { "BUTTON_4", 191 },
964
220
    { "BUTTON_5", 192 },
965
221
    { "BUTTON_6", 193 },
966
222
    { "BUTTON_7", 194 },
967
223
    { "BUTTON_8", 195 },
968
224
    { "BUTTON_9", 196 },
969
225
    { "BUTTON_10", 197 },
970
226
    { "BUTTON_11", 198 },
971
227
    { "BUTTON_12", 199 },
972
228
    { "BUTTON_13", 200 },
973
229
    { "BUTTON_14", 201 },
974
230
    { "BUTTON_15", 202 },
975
231
    { "BUTTON_16", 203 },
976
232
    { "LANGUAGE_SWITCH", 204 },
977
233
    { "MANNER_MODE", 205 },
978
234
    { "3D_MODE", 206 },
979
235
    { "CONTACTS", 207 },
980
236
    { "CALENDAR", 208 },
981
237
    { "MUSIC", 209 },
982
238
    { "CALCULATOR", 210 },
983
239
    { "ZENKAKU_HANKAKU", 211 },
984
240
    { "EISU", 212 },
985
241
    { "MUHENKAN", 213 },
986
242
    { "HENKAN", 214 },
987
243
    { "KATAKANA_HIRAGANA", 215 },
988
244
    { "YEN", 216 },
989
245
    { "RO", 217 },
990
246
    { "KANA", 218 },
991
247
    { "ASSIST", 219 },
992
248
993
249
    // NOTE: If you add a new keycode here you must also add it to several other files.
994
250
    //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.
995
251
996
252
    { NULL, 0 }
997
253
};
998
254
999
255
// NOTE: If you edit these flags, also edit policy flags in Input.h.
1000
256
static const KeycodeLabel FLAGS[] = {
1001
257
    { "WAKE", 0x00000001 },
1002
258
    { "WAKE_DROPPED", 0x00000002 },
1003
259
    { "SHIFT", 0x00000004 },
1004
260
    { "CAPS_LOCK", 0x00000008 },
1005
261
    { "ALT", 0x00000010 },
1006
262
    { "ALT_GR", 0x00000020 },
1007
263
    { "MENU", 0x00000040 },
1008
264
    { "LAUNCHER", 0x00000080 },
1009
265
    { "VIRTUAL", 0x00000100 },
1010
266
    { "FUNCTION", 0x00000200 },
1011
267
    { NULL, 0 }
1012
268
};
1013
269
1014
270
static const KeycodeLabel AXES[] = {
1015
271
    { "X", 0 },
1016
272
    { "Y", 1 },
1017
273
    { "PRESSURE", 2 },
1018
274
    { "SIZE", 3 },
1019
275
    { "TOUCH_MAJOR", 4 },
1020
276
    { "TOUCH_MINOR", 5 },
1021
277
    { "TOOL_MAJOR", 6 },
1022
278
    { "TOOL_MINOR", 7 },
1023
279
    { "ORIENTATION", 8 },
1024
280
    { "VSCROLL", 9 },
1025
281
    { "HSCROLL", 10 },
1026
282
    { "Z", 11 },
1027
283
    { "RX", 12 },
1028
284
    { "RY", 13 },
1029
285
    { "RZ", 14 },
1030
286
    { "HAT_X", 15 },
1031
287
    { "HAT_Y", 16 },
1032
288
    { "LTRIGGER", 17 },
1033
289
    { "RTRIGGER", 18 },
1034
290
    { "THROTTLE", 19 },
1035
291
    { "RUDDER", 20 },
1036
292
    { "WHEEL", 21 },
1037
293
    { "GAS", 22 },
1038
294
    { "BRAKE", 23 },
1039
295
    { "DISTANCE", 24 },
1040
296
    { "TILT", 25 },
1041
297
    { "GENERIC_1", 32 },
1042
298
    { "GENERIC_2", 33 },
1043
299
    { "GENERIC_3", 34 },
1044
300
    { "GENERIC_4", 35 },
1045
301
    { "GENERIC_5", 36 },
1046
302
    { "GENERIC_6", 37 },
1047
303
    { "GENERIC_7", 38 },
1048
304
    { "GENERIC_8", 39 },
1049
305
    { "GENERIC_9", 40 },
1050
306
    { "GENERIC_10", 41 },
1051
307
    { "GENERIC_11", 42 },
1052
308
    { "GENERIC_12", 43 },
1053
309
    { "GENERIC_13", 44 },
1054
310
    { "GENERIC_14", 45 },
1055
311
    { "GENERIC_15", 46 },
1056
312
    { "GENERIC_16", 47 },
1057
313
1058
314
    // NOTE: If you add a new axis here you must also add it to several other files.
1059
315
    //       Refer to frameworks/base/core/java/android/view/MotionEvent.java for the full list.
1060
316
1061
317
    { NULL, -1 }
1062
318
};
1063
319
1064
320
#endif // _ANDROIDFW_KEYCODE_LABELS_H
1065
321
0
1066
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h'
1067
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	2015-04-28 07:54:10 +0000
1068
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityControl.h	1970-01-01 00:00:00 +0000
1069
@@ -1,110 +0,0 @@
1070
1
/*
1071
2
 * Copyright (C) 2012 The Android Open Source Project
1072
3
 *
1073
4
 * Licensed under the Apache License, Version 2.0 (the "License");
1074
5
 * you may not use this file except in compliance with the License.
1075
6
 * You may obtain a copy of the License at
1076
7
 *
1077
8
 *      http://www.apache.org/licenses/LICENSE-2.0
1078
9
 *
1079
10
 * Unless required by applicable law or agreed to in writing, software
1080
11
 * distributed under the License is distributed on an "AS IS" BASIS,
1081
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1082
13
 * See the License for the specific language governing permissions and
1083
14
 * limitations under the License.
1084
15
 */
1085
16
1086
17
#ifndef _ANDROIDFW_VELOCITY_CONTROL_H
1087
18
#define _ANDROIDFW_VELOCITY_CONTROL_H
1088
19
1089
20
1090
21
#include <androidfw/Input.h>
1091
22
#include <androidfw/IntSet.h>
1092
23
#include <androidfw/VelocityTracker.h>
1093
24
#include <std/Timers.h>
1094
25
1095
26
namespace android {
1096
27
1097
28
/*
1098
29
 * Specifies parameters that govern pointer or wheel acceleration.
1099
30
 */
1100
31
struct VelocityControlParameters {
1101
32
    // A scale factor that is multiplied with the raw velocity deltas
1102
33
    // prior to applying any other velocity control factors.  The scale
1103
34
    // factor should be used to adapt the input device resolution
1104
35
    // (eg. counts per inch) to the output device resolution (eg. pixels per inch).
1105
36
    //
1106
37
    // Must be a positive value.
1107
38
    // Default is 1.0 (no scaling).
1108
39
    float scale;
1109
40
1110
41
    // The scaled speed at which acceleration begins to be applied.
1111
42
    // This value establishes the upper bound of a low speed regime for
1112
43
    // small precise motions that are performed without any acceleration.
1113
44
    //
1114
45
    // Must be a non-negative value.
1115
46
    // Default is 0.0 (no low threshold).
1116
47
    float lowThreshold;
1117
48
1118
49
    // The scaled speed at which maximum acceleration is applied.
1119
50
    // The difference between highThreshold and lowThreshold controls
1120
51
    // the range of speeds over which the acceleration factor is interpolated.
1121
52
    // The wider the range, the smoother the acceleration.
1122
53
    //
1123
54
    // Must be a non-negative value greater than or equal to lowThreshold.
1124
55
    // Default is 0.0 (no high threshold).
1125
56
    float highThreshold;
1126
57
1127
58
    // The acceleration factor.
1128
59
    // When the speed is above the low speed threshold, the velocity will scaled
1129
60
    // by an interpolated value between 1.0 and this amount.
1130
61
    //
1131
62
    // Must be a positive greater than or equal to 1.0.
1132
63
    // Default is 1.0 (no acceleration).
1133
64
    float acceleration;
1134
65
1135
66
    VelocityControlParameters() :
1136
67
            scale(1.0f), lowThreshold(0.0f), highThreshold(0.0f), acceleration(1.0f) {
1137
68
    }
1138
69
1139
70
    VelocityControlParameters(float scale, float lowThreshold,
1140
71
            float highThreshold, float acceleration) :
1141
72
            scale(scale), lowThreshold(lowThreshold),
1142
73
            highThreshold(highThreshold), acceleration(acceleration) {
1143
74
    }
1144
75
};
1145
76
1146
77
/*
1147
78
 * Implements mouse pointer and wheel speed control and acceleration.
1148
79
 */
1149
80
class VelocityControl {
1150
81
public:
1151
82
    VelocityControl();
1152
83
1153
84
    /* Sets the various parameters. */
1154
85
    void setParameters(const VelocityControlParameters& parameters);
1155
86
1156
87
    /* Resets the current movement counters to zero.
1157
88
     * This has the effect of nullifying any acceleration. */
1158
89
    void reset();
1159
90
1160
91
    /* Translates a raw movement delta into an appropriately
1161
92
     * scaled / accelerated delta based on the current velocity. */
1162
93
    void move(std::chrono::nanoseconds eventTime, float* deltaX, float* deltaY);
1163
94
1164
95
private:
1165
96
    // If no movements are received within this amount of time,
1166
97
    // we assume the movement has stopped and reset the movement counters.
1167
98
    static constexpr const std::chrono::nanoseconds STOP_TIME = std::chrono::nanoseconds(500 * 1000000); // 500 ms
1168
99
1169
100
    VelocityControlParameters mParameters;
1170
101
1171
102
    std::chrono::nanoseconds mLastMovementTime;
1172
103
    VelocityTracker::Position mRawPosition;
1173
104
    VelocityTracker mVelocityTracker;
1174
105
    IntSet mIds;
1175
106
};
1176
107
1177
108
} // namespace android
1178
109
1179
110
#endif // _ANDROIDFW_VELOCITY_CONTROL_H
1180
111
0
1181
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h'
1182
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	2015-04-28 07:54:10 +0000
1183
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VelocityTracker.h	1970-01-01 00:00:00 +0000
1184
@@ -1,272 +0,0 @@
1185
1
/*
1186
2
 * Copyright (C) 2012 The Android Open Source Project
1187
3
 *
1188
4
 * Licensed under the Apache License, Version 2.0 (the "License");
1189
5
 * you may not use this file except in compliance with the License.
1190
6
 * You may obtain a copy of the License at
1191
7
 *
1192
8
 *      http://www.apache.org/licenses/LICENSE-2.0
1193
9
 *
1194
10
 * Unless required by applicable law or agreed to in writing, software
1195
11
 * distributed under the License is distributed on an "AS IS" BASIS,
1196
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1197
13
 * See the License for the specific language governing permissions and
1198
14
 * limitations under the License.
1199
15
 */
1200
16
1201
17
#ifndef _ANDROIDFW_VELOCITY_TRACKER_H
1202
18
#define _ANDROIDFW_VELOCITY_TRACKER_H
1203
19
1204
20
#include <androidfw/Input.h>
1205
21
#include <androidfw/IntSet.h>
1206
22
#include <std/Timers.h>
1207
23
1208
24
// C++ std lib
1209
25
#include <unordered_map>
1210
26
1211
27
namespace android {
1212
28
1213
29
class VelocityTrackerStrategy;
1214
30
1215
31
/*
1216
32
 * Calculates the velocity of pointer movements over time.
1217
33
 */
1218
34
class VelocityTracker {
1219
35
public:
1220
36
    struct Position {
1221
37
        float x, y;
1222
38
    };
1223
39
1224
40
    struct Estimator {
1225
41
        static const size_t MAX_DEGREE = 4;
1226
42
1227
43
        // Estimator time base.
1228
44
        std::chrono::nanoseconds time;
1229
45
1230
46
        // Polynomial coefficients describing motion in X and Y.
1231
47
        float xCoeff[MAX_DEGREE + 1], yCoeff[MAX_DEGREE + 1];
1232
48
1233
49
        // Polynomial degree (number of coefficients), or zero if no information is
1234
50
        // available.
1235
51
        uint32_t degree;
1236
52
1237
53
        // Confidence (coefficient of determination), between 0 (no fit) and 1 (perfect fit).
1238
54
        float confidence;
1239
55
1240
56
        inline void clear() {
1241
57
            time = std::chrono::nanoseconds(0);
1242
58
            degree = 0;
1243
59
            confidence = 0;
1244
60
            for (size_t i = 0; i <= MAX_DEGREE; i++) {
1245
61
                xCoeff[i] = 0;
1246
62
                yCoeff[i] = 0;
1247
63
            }
1248
64
        }
1249
65
    };
1250
66
1251
67
    // Creates a velocity tracker using the specified strategy.
1252
68
    // If strategy is NULL, uses the default strategy for the platform.
1253
69
    VelocityTracker(const char* strategy = NULL);
1254
70
1255
71
    ~VelocityTracker();
1256
72
1257
73
    // Resets the velocity tracker state.
1258
74
    void clear();
1259
75
1260
76
    // Resets the velocity tracker state for specific pointers.
1261
77
    // Call this method when some pointers have changed and may be reusing
1262
78
    // an id that was assigned to a different pointer earlier.
1263
79
    void clearPointers(const IntSet &ids);
1264
80
1265
81
    // Adds movement information for a set of pointers.
1266
82
    // The ids set specifies the pointer ids of the pointers whose positions
1267
83
    // are included in the movement.
1268
84
    // The positions array contains position information for each pointer in order by
1269
85
    // increasing id.  Its size should be equal to the size of ids.
1270
86
    void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids, const Position* positions);
1271
87
1272
88
    // Adds movement information for all pointers in a MotionEvent, including historical samples.
1273
89
    void addMovement(const MotionEvent* event);
1274
90
1275
91
    // Gets the velocity of the specified pointer id in position units per second.
1276
92
    // Returns false and sets the velocity components to zero if there is
1277
93
    // insufficient movement information for the pointer.
1278
94
    bool getVelocity(uint32_t id, float* outVx, float* outVy) const;
1279
95
1280
96
    // Gets an estimator for the recent movements of the specified pointer id.
1281
97
    // Returns false and clears the estimator if there is no information available
1282
98
    // about the pointer.
1283
99
    bool getEstimator(uint32_t id, Estimator* outEstimator) const;
1284
100
1285
101
    // Gets the active pointer id, or -1 if none.
1286
102
    inline int32_t getActivePointerId() const { return mActivePointerId; }
1287
103
1288
104
    // Gets a bitset containing all pointer ids from the most recent movement.
1289
105
    inline const IntSet &getCurrentPointerIds() const { return mCurrentPointerIds; }
1290
106
1291
107
private:
1292
108
    static const char* DEFAULT_STRATEGY;
1293
109
1294
110
    std::chrono::nanoseconds mLastEventTime;
1295
111
    IntSet mCurrentPointerIds;
1296
112
    int32_t mActivePointerId;
1297
113
    VelocityTrackerStrategy* mStrategy;
1298
114
1299
115
    bool configureStrategy(const char* strategy);
1300
116
1301
117
    static VelocityTrackerStrategy* createStrategy(const char* strategy);
1302
118
};
1303
119
1304
120
1305
121
/*
1306
122
 * Implements a particular velocity tracker algorithm.
1307
123
 */
1308
124
class VelocityTrackerStrategy {
1309
125
protected:
1310
126
    VelocityTrackerStrategy() { }
1311
127
1312
128
public:
1313
129
    virtual ~VelocityTrackerStrategy() { }
1314
130
1315
131
    virtual void clear() = 0;
1316
132
    virtual void clearPointers(const IntSet &ids) = 0;
1317
133
    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
1318
134
            const VelocityTracker::Position* positions) = 0;
1319
135
    virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const = 0;
1320
136
};
1321
137
1322
138
1323
139
/*
1324
140
 * Velocity tracker algorithm based on least-squares linear regression.
1325
141
 */
1326
142
class LeastSquaresVelocityTrackerStrategy : public VelocityTrackerStrategy {
1327
143
public:
1328
144
    enum Weighting {
1329
145
        // No weights applied.  All data points are equally reliable.
1330
146
        WEIGHTING_NONE,
1331
147
1332
148
        // Weight by time delta.  Data points clustered together are weighted less.
1333
149
        WEIGHTING_DELTA,
1334
150
1335
151
        // Weight such that points within a certain horizon are weighed more than those
1336
152
        // outside of that horizon.
1337
153
        WEIGHTING_CENTRAL,
1338
154
1339
155
        // Weight such that points older than a certain amount are weighed less.
1340
156
        WEIGHTING_RECENT
1341
157
    };
1342
158
1343
159
    // Degree must be no greater than Estimator::MAX_DEGREE.
1344
160
    LeastSquaresVelocityTrackerStrategy(uint32_t degree, Weighting weighting = WEIGHTING_NONE);
1345
161
    virtual ~LeastSquaresVelocityTrackerStrategy();
1346
162
1347
163
    virtual void clear();
1348
164
    virtual void clearPointers(const IntSet &ids);
1349
165
    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
1350
166
            const VelocityTracker::Position* positions);
1351
167
    virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
1352
168
1353
169
private:
1354
170
    // Sample horizon.
1355
171
    // We don't use too much history by default since we want to react to quick
1356
172
    // changes in direction.
1357
173
    static constexpr const std::chrono::nanoseconds HORIZON = std::chrono::nanoseconds(100 * 1000000); // 100 ms
1358
174
1359
175
    // Number of samples to keep.
1360
176
    static const uint32_t HISTORY_SIZE = 20;
1361
177
1362
178
    struct Movement {
1363
179
        std::chrono::nanoseconds eventTime;
1364
180
        IntSet ids;
1365
181
        VelocityTracker::Position positions[MAX_POINTERS];
1366
182
1367
183
        inline const VelocityTracker::Position& getPosition(uint32_t id) const {
1368
184
            return positions[ids.indexOf(id)];
1369
185
        }
1370
186
    };
1371
187
1372
188
    float chooseWeight(uint32_t index) const;
1373
189
1374
190
    const uint32_t mDegree;
1375
191
    const Weighting mWeighting;
1376
192
    uint32_t mIndex;
1377
193
    Movement mMovements[HISTORY_SIZE];
1378
194
};
1379
195
1380
196
1381
197
/*
1382
198
 * Velocity tracker algorithm that uses an IIR filter.
1383
199
 */
1384
200
class IntegratingVelocityTrackerStrategy : public VelocityTrackerStrategy {
1385
201
public:
1386
202
    // Degree must be 1 or 2.
1387
203
    IntegratingVelocityTrackerStrategy(uint32_t degree);
1388
204
    ~IntegratingVelocityTrackerStrategy();
1389
205
1390
206
    virtual void clear();
1391
207
    virtual void clearPointers(const IntSet &ids);
1392
208
    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
1393
209
            const VelocityTracker::Position* positions);
1394
210
    virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
1395
211
1396
212
private:
1397
213
    // Current state estimate for a particular pointer.
1398
214
    struct State {
1399
215
        std::chrono::nanoseconds updateTime;
1400
216
        uint32_t degree;
1401
217
1402
218
        float xpos, xvel, xaccel;
1403
219
        float ypos, yvel, yaccel;
1404
220
    };
1405
221
1406
222
    const uint32_t mDegree;
1407
223
    IntSet mPointerIds;
1408
224
    std::unordered_map<int32_t, State> mPointerState; // maps the id of a pointer to its state
1409
225
1410
226
    void initState(State& state, std::chrono::nanoseconds eventTime, float xpos, float ypos) const;
1411
227
    void updateState(State& state, std::chrono::nanoseconds eventTime, float xpos, float ypos) const;
1412
228
    void populateEstimator(const State& state, VelocityTracker::Estimator* outEstimator) const;
1413
229
};
1414
230
1415
231
1416
232
/*
1417
233
 * Velocity tracker strategy used prior to ICS.
1418
234
 */
1419
235
class LegacyVelocityTrackerStrategy : public VelocityTrackerStrategy {
1420
236
public:
1421
237
    LegacyVelocityTrackerStrategy();
1422
238
    virtual ~LegacyVelocityTrackerStrategy();
1423
239
1424
240
    virtual void clear();
1425
241
    virtual void clearPointers(const IntSet &ids);
1426
242
    virtual void addMovement(std::chrono::nanoseconds eventTime, const IntSet &ids,
1427
243
            const VelocityTracker::Position* positions);
1428
244
    virtual bool getEstimator(uint32_t id, VelocityTracker::Estimator* outEstimator) const;
1429
245
1430
246
private:
1431
247
    // Oldest sample to consider when calculating the velocity.
1432
248
    static constexpr const std::chrono::nanoseconds HORIZON = std::chrono::nanoseconds(200 * 1000000); // 100 ms
1433
249
1434
250
    // Number of samples to keep.
1435
251
    static const uint32_t HISTORY_SIZE = 20;
1436
252
1437
253
    // The minimum duration between samples when estimating velocity.
1438
254
    static constexpr const std::chrono::nanoseconds MIN_DURATION = std::chrono::nanoseconds(10 * 1000000); // 10 ms
1439
255
1440
256
    struct Movement {
1441
257
        std::chrono::nanoseconds eventTime;
1442
258
        IntSet ids;
1443
259
        VelocityTracker::Position positions[MAX_POINTERS];
1444
260
1445
261
        inline const VelocityTracker::Position& getPosition(uint32_t id) const {
1446
262
            return positions[ids.indexOf(id)];
1447
263
        }
1448
264
    };
1449
265
1450
266
    uint32_t mIndex;
1451
267
    Movement mMovements[HISTORY_SIZE];
1452
268
};
1453
269
1454
270
} // namespace android
1455
271
1456
272
#endif // _ANDROIDFW_VELOCITY_TRACKER_H
1457
273
0
1458
=== removed file '3rd_party/android-input/android/frameworks/base/include/androidfw/VirtualKeyMap.h'
1459
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/VirtualKeyMap.h	2013-05-03 16:38:07 +0000
1460
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/VirtualKeyMap.h	1970-01-01 00:00:00 +0000
1461
@@ -1,81 +0,0 @@
1462
1
/*
1463
2
 * Copyright (C) 2010 The Android Open Source Project
1464
3
 *
1465
4
 * Licensed under the Apache License, Version 2.0 (the "License");
1466
5
 * you may not use this file except in compliance with the License.
1467
6
 * You may obtain a copy of the License at
1468
7
 *
1469
8
 *      http://www.apache.org/licenses/LICENSE-2.0
1470
9
 *
1471
10
 * Unless required by applicable law or agreed to in writing, software
1472
11
 * distributed under the License is distributed on an "AS IS" BASIS,
1473
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1474
13
 * See the License for the specific language governing permissions and
1475
14
 * limitations under the License.
1476
15
 */
1477
16
1478
17
#ifndef _ANDROIDFW_VIRTUAL_KEY_MAP_H
1479
18
#define _ANDROIDFW_VIRTUAL_KEY_MAP_H
1480
19
1481
20
1482
21
#include <stdint.h>
1483
22
1484
23
#include <androidfw/Input.h>
1485
24
#include <std/Errors.h>
1486
25
#include <std/KeyedVector.h>
1487
26
#include <std/Tokenizer.h>
1488
27
#include <std/String8.h>
1489
28
1490
29
namespace android {
1491
30
1492
31
/* Describes a virtual key. */
1493
32
struct VirtualKeyDefinition {
1494
33
    int32_t scanCode;
1495
34
1496
35
    // configured position data, specified in display coords
1497
36
    int32_t centerX;
1498
37
    int32_t centerY;
1499
38
    int32_t width;
1500
39
    int32_t height;
1501
40
};
1502
41
1503
42
1504
43
/**
1505
44
 * Describes a collection of virtual keys on a touch screen in terms of
1506
45
 * virtual scan codes and hit rectangles.
1507
46
 *
1508
47
 * This object is immutable after it has been loaded.
1509
48
 */
1510
49
class VirtualKeyMap {
1511
50
public:
1512
51
    ~VirtualKeyMap();
1513
52
1514
53
    static status_t load(const String8& filename, VirtualKeyMap** outMap);
1515
54
1516
55
    inline const Vector<VirtualKeyDefinition>& getVirtualKeys() const {
1517
56
        return mVirtualKeys;
1518
57
    }
1519
58
1520
59
private:
1521
60
    class Parser {
1522
61
        VirtualKeyMap* mMap;
1523
62
        Tokenizer* mTokenizer;
1524
63
1525
64
    public:
1526
65
        Parser(VirtualKeyMap* map, Tokenizer* tokenizer);
1527
66
        ~Parser();
1528
67
        status_t parse();
1529
68
1530
69
    private:
1531
70
        bool consumeFieldDelimiterAndSkipWhitespace();
1532
71
        bool parseNextIntField(int32_t* outValue);
1533
72
    };
1534
73
1535
74
    Vector<VirtualKeyDefinition> mVirtualKeys;
1536
75
1537
76
    VirtualKeyMap();
1538
77
};
1539
78
1540
79
} // namespace android
1541
80
1542
81
#endif // _ANDROIDFW_KEY_CHARACTER_MAP_H
1543
82
0
1544
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp'
1545
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	2015-08-19 02:03:51 +0000
1546
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.cpp	1970-01-01 00:00:00 +0000
1547
@@ -1,1502 +0,0 @@
1548
1
/*
1549
2
 * Copyright (C) 2005 The Android Open Source Project
1550
3
 *
1551
4
 * Licensed under the Apache License, Version 2.0 (the "License");
1552
5
 * you may not use this file except in compliance with the License.
1553
6
 * You may obtain a copy of the License at
1554
7
 *
1555
8
 *      http://www.apache.org/licenses/LICENSE-2.0
1556
9
 *
1557
10
 * Unless required by applicable law or agreed to in writing, software
1558
11
 * distributed under the License is distributed on an "AS IS" BASIS,
1559
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1560
13
 * See the License for the specific language governing permissions and
1561
14
 * limitations under the License.
1562
15
 */
1563
16
1564
17
#define LOG_TAG "EventHub"
1565
18
1566
19
// #define LOG_NDEBUG 0
1567
20
1568
21
#include "EventHub.h"
1569
22
1570
23
#define acquire_wake_lock(lock, id) {}
1571
24
#define release_wake_lock(id) {}
1572
25
1573
26
#include "mir/input/input_report.h"
1574
27
#include "mir/udev/wrapper.h"
1575
28
1576
29
#include <cutils/properties.h>
1577
30
#include <std/Log.h>
1578
31
#include <std/Timers.h>
1579
32
#include <std/Errors.h>
1580
33
1581
34
#include <stdlib.h>
1582
35
#include <unistd.h>
1583
36
#include <fcntl.h>
1584
37
#include <memory.h>
1585
38
#include <errno.h>
1586
39
#include <assert.h>
1587
40
1588
41
#include <androidfw/KeyLayoutMap.h>
1589
42
#include <androidfw/KeyCharacterMap.h>
1590
43
#include <androidfw/VirtualKeyMap.h>
1591
44
1592
45
#include <android/keycodes.h>
1593
46
#include <boost/uuid/sha1.hpp>
1594
47
1595
48
#include <string.h>
1596
49
#include <stdint.h>
1597
50
#include <dirent.h>
1598
51
1599
52
#include <sys/inotify.h>
1600
53
#include <sys/epoll.h>
1601
54
#include <sys/ioctl.h>
1602
55
#include <sys/timerfd.h>
1603
56
// <mir changes>
1604
57
// Needed to build on android platform (PATH_MAX)
1605
58
#ifdef HAVE_ANDROID_OS
1606
59
#include <sys/limits.h>
1607
60
#endif
1608
61
#include <linux/limits.h>
1609
62
// </mir changes>
1610
63
1611
64
/* this macro is used to tell if "bit" is set in "array"
1612
65
 * it selects a byte from the array, and does a boolean AND
1613
66
 * operation with a byte that only has the relevant bit set.
1614
67
 * eg. to check for the 12th bit, we do (array[1] & 1<<4)
1615
68
 */
1616
69
#define test_bit(bit, array)    (array[bit/8] & (1<<(bit%8)))
1617
70
1618
71
/* this macro computes the number of bytes needed to represent a bit array of the specified size */
1619
72
#define sizeof_bit_array(bits)  ((bits + 7) / 8)
1620
73
1621
74
#define INDENT "  "
1622
75
#define INDENT2 "    "
1623
76
#define INDENT3 "      "
1624
77
1625
78
namespace mi = mir::input;
1626
79
1627
80
namespace android {
1628
81
1629
82
static const char *WAKE_LOCK_ID = "KeyEvents";
1630
83
static const char *DEVICE_PATH = "/dev/input";
1631
84
1632
85
/* return the larger integer */
1633
86
static inline int max(int v1, int v2)
1634
87
{
1635
88
    return (v1 > v2) ? v1 : v2;
1636
89
}
1637
90
1638
91
static inline const char* toString(bool value) {
1639
92
    return value ? "true" : "false";
1640
93
}
1641
94
1642
95
namespace detail
1643
96
{
1644
97
String8 sha1(const String8& in) {
1645
98
    boost::uuids::detail::sha1 hasher;
1646
99
    hasher.process_bytes(in.data(), in.size());
1647
100
1648
101
    unsigned int digest[5];
1649
102
    hasher.get_digest(digest);
1650
103
1651
104
    String8 out;
1652
105
    for(int i : digest) {
1653
106
        appendFormat(out, "%08x", i);
1654
107
    }
1655
108
1656
109
    return out;
1657
110
}
1658
111
}
1659
112
1660
113
using detail::sha1;
1661
114
1662
115
static void setDescriptor(InputDeviceIdentifier& identifier) {
1663
116
    // Compute a device descriptor that uniquely identifies the device.
1664
117
    // The descriptor is assumed to be a stable identifier.  Its value should not
1665
118
    // change between reboots, reconnections, firmware updates or new releases of Android.
1666
119
    // Ideally, we also want the descriptor to be short and relatively opaque.
1667
120
    String8 rawDescriptor;
1668
121
    appendFormat(rawDescriptor, ":%04x:%04x:", identifier.vendor, identifier.product);
1669
122
    if (!isEmpty(identifier.uniqueId)) {
1670
123
        rawDescriptor.append("uniqueId:");
1671
124
        rawDescriptor.append(identifier.uniqueId);
1672
125
    } if (identifier.vendor == 0 && identifier.product == 0) {
1673
126
        // If we don't know the vendor and product id, then the device is probably
1674
127
        // built-in so we need to rely on other information to uniquely identify
1675
128
        // the input device.  Usually we try to avoid relying on the device name or
1676
129
        // location but for built-in input device, they are unlikely to ever change.
1677
130
        if (!isEmpty(identifier.name)) {
1678
131
            rawDescriptor.append("name:");
1679
132
            rawDescriptor.append(identifier.name);
1680
133
        } else if (!isEmpty(identifier.location)) {
1681
134
            rawDescriptor.append("location:");
1682
135
            rawDescriptor.append(identifier.location);
1683
136
        }
1684
137
    }
1685
138
    identifier.descriptor = sha1(rawDescriptor);
1686
139
    ALOGV("Created descriptor: raw=%s, cooked=%s", c_str(rawDescriptor),
1687
140
        c_str(identifier.descriptor));
1688
141
}
1689
142
1690
143
// --- EventHub::Device ---
1691
144
1692
145
EventHub::Device::Device(int fd, int32_t id, const String8& path,
1693
146
        const InputDeviceIdentifier& identifier) :
1694
147
        next(NULL),
1695
148
        fd(fd), id(id), path(path), identifier(identifier),
1696
149
        classes(0), configuration(NULL), virtualKeyMap(NULL),
1697
150
        ffEffectPlaying(false), ffEffectId(-1) {
1698
151
    memset(keyBitmask, 0, sizeof(keyBitmask));
1699
152
    memset(absBitmask, 0, sizeof(absBitmask));
1700
153
    memset(relBitmask, 0, sizeof(relBitmask));
1701
154
    memset(swBitmask, 0, sizeof(swBitmask));
1702
155
    memset(ledBitmask, 0, sizeof(ledBitmask));
1703
156
    memset(ffBitmask, 0, sizeof(ffBitmask));
1704
157
    memset(propBitmask, 0, sizeof(propBitmask));
1705
158
}
1706
159
1707
160
EventHub::Device::~Device() {
1708
161
    close();
1709
162
    delete configuration;
1710
163
    delete virtualKeyMap;
1711
164
}
1712
165
1713
166
void EventHub::Device::close() {
1714
167
    if (fd >= 0) {
1715
168
        ::close(fd);
1716
169
        fd = -1;
1717
170
    }
1718
171
}
1719
172
1720
173
1721
174
// --- EventHub ---
1722
175
1723
176
const uint32_t EventHub::EPOLL_ID_UDEV;
1724
177
const uint32_t EventHub::EPOLL_ID_WAKE;
1725
178
const uint32_t EventHub::EPOLL_ID_TIMER;
1726
179
const int EventHub::EPOLL_SIZE_HINT;
1727
180
const int EventHub::EPOLL_MAX_EVENTS;
1728
181
1729
182
EventHub::EventHub(std::shared_ptr<mi::InputReport> const& input_report) :
1730
183
        input_report(input_report),
1731
184
        device_listener{new mir::udev::Monitor{mir::udev::Context()}},
1732
185
        mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1),
1733
186
        mOpeningDevices(0), mClosingDevices(0),
1734
187
        mNeedToSendFinishedDeviceScan(false),
1735
188
        mNeedToReopenDevices(false), mNeedToScanDevices(true),
1736
189
        mEpollFd{epoll_create(EPOLL_SIZE_HINT)},
1737
190
        mTimerFd{timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)},
1738
191
        mPendingEventCount(0), mPendingEventIndex(0), mPendingUdevEvent(false) {
1739
192
    acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
1740
193
1741
194
    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);
1742
195
    LOG_ALWAYS_FATAL_IF(mTimerFd < 0, "Could not create timerfd.  errno=%d", errno);
1743
196
1744
197
    device_listener->filter_by_subsystem("input");
1745
198
    device_listener->enable();
1746
199
1747
200
1748
201
    struct epoll_event eventItem;
1749
202
    memset(&eventItem, 0, sizeof(eventItem));
1750
203
    eventItem.events = EPOLLIN;
1751
204
    eventItem.data.u32 = EPOLL_ID_UDEV;
1752
205
    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, device_listener->fd(), &eventItem);
1753
206
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add Udev monitor to epoll instance.  errno=%d", errno);
1754
207
1755
208
    int wakeFds[2];
1756
209
    result = pipe(wakeFds);
1757
210
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);
1758
211
1759
212
    mWakeReadPipeFd = wakeFds[0];
1760
213
    mWakeWritePipeFd = wakeFds[1];
1761
214
1762
215
    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
1763
216
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",
1764
217
            errno);
1765
218
1766
219
    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
1767
220
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",
1768
221
            errno);
1769
222
1770
223
    eventItem.data.u32 = EPOLL_ID_WAKE;
1771
224
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
1772
225
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",
1773
226
            errno);
1774
227
1775
228
    eventItem.data.u32 = EPOLL_ID_TIMER;
1776
229
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mTimerFd, &eventItem);
1777
230
    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add timer fd to epoll instance.  errno=%d",
1778
231
                        errno);
1779
232
}
1780
233
1781
234
EventHub::~EventHub(void) {
1782
235
    closeAllDevicesLocked();
1783
236
1784
237
    while (mClosingDevices) {
1785
238
        Device* device = mClosingDevices;
1786
239
        mClosingDevices = device->next;
1787
240
        delete device;
1788
241
    }
1789
242
1790
243
    ::close(mWakeReadPipeFd);
1791
244
    ::close(mWakeWritePipeFd);
1792
245
1793
246
    release_wake_lock(WAKE_LOCK_ID);
1794
247
}
1795
248
1796
249
InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const {
1797
250
    AutoMutex _l(mLock);
1798
251
    Device* device = getDeviceLocked(deviceId);
1799
252
    if (device == NULL) return InputDeviceIdentifier();
1800
253
    return device->identifier;
1801
254
}
1802
255
1803
256
uint32_t EventHub::getDeviceClasses(int32_t deviceId) const {
1804
257
    AutoMutex _l(mLock);
1805
258
    Device* device = getDeviceLocked(deviceId);
1806
259
    if (device == NULL) return 0;
1807
260
    return device->classes;
1808
261
}
1809
262
1810
263
void EventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const {
1811
264
    AutoMutex _l(mLock);
1812
265
    Device* device = getDeviceLocked(deviceId);
1813
266
    if (device && device->configuration) {
1814
267
        *outConfiguration = *device->configuration;
1815
268
    } else {
1816
269
        outConfiguration->clear();
1817
270
    }
1818
271
}
1819
272
1820
273
status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
1821
274
        RawAbsoluteAxisInfo* outAxisInfo) const {
1822
275
    outAxisInfo->clear();
1823
276
1824
277
    if (axis >= 0 && axis <= ABS_MAX) {
1825
278
        AutoMutex _l(mLock);
1826
279
1827
280
        Device* device = getDeviceLocked(deviceId);
1828
281
        if (device && !device->isVirtual() && test_bit(axis, device->absBitmask)) {
1829
282
            struct input_absinfo info;
1830
283
            if(ioctl(device->fd, EVIOCGABS(axis), &info)) {
1831
284
                ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",
1832
285
                     axis, c_str(device->identifier.name), device->fd, errno);
1833
286
                return -errno;
1834
287
            }
1835
288
1836
289
            if (info.minimum != info.maximum) {
1837
290
                outAxisInfo->valid = true;
1838
291
                outAxisInfo->minValue = info.minimum;
1839
292
                outAxisInfo->maxValue = info.maximum;
1840
293
                outAxisInfo->flat = info.flat;
1841
294
                outAxisInfo->fuzz = info.fuzz;
1842
295
                outAxisInfo->resolution = info.resolution;
1843
296
            }
1844
297
            return OK;
1845
298
        }
1846
299
    }
1847
300
    return -1;
1848
301
}
1849
302
1850
303
bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
1851
304
    if (axis >= 0 && axis <= REL_MAX) {
1852
305
        AutoMutex _l(mLock);
1853
306
1854
307
        Device* device = getDeviceLocked(deviceId);
1855
308
        if (device) {
1856
309
            return test_bit(axis, device->relBitmask);
1857
310
        }
1858
311
    }
1859
312
    return false;
1860
313
}
1861
314
1862
315
bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
1863
316
    if (property >= 0 && property <= INPUT_PROP_MAX) {
1864
317
        AutoMutex _l(mLock);
1865
318
1866
319
        Device* device = getDeviceLocked(deviceId);
1867
320
        if (device) {
1868
321
            return test_bit(property, device->propBitmask);
1869
322
        }
1870
323
    }
1871
324
    return false;
1872
325
}
1873
326
1874
327
int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
1875
328
    if (scanCode >= 0 && scanCode <= KEY_MAX) {
1876
329
        AutoMutex _l(mLock);
1877
330
1878
331
        Device* device = getDeviceLocked(deviceId);
1879
332
        if (device && !device->isVirtual() && test_bit(scanCode, device->keyBitmask)) {
1880
333
            uint8_t keyState[sizeof_bit_array(KEY_MAX + 1)];
1881
334
            memset(keyState, 0, sizeof(keyState));
1882
335
            if (ioctl(device->fd, EVIOCGKEY(sizeof(keyState)), keyState) >= 0) {
1883
336
                return test_bit(scanCode, keyState) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
1884
337
            }
1885
338
        }
1886
339
    }
1887
340
    return AKEY_STATE_UNKNOWN;
1888
341
}
1889
342
1890
343
int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
1891
344
    AutoMutex _l(mLock);
1892
345
1893
346
    Device* device = getDeviceLocked(deviceId);
1894
347
    if (device && !device->isVirtual() && device->keyMap.haveKeyLayout()) {
1895
348
        Vector<int32_t> scanCodes;
1896
349
        device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes);
1897
350
        if (scanCodes.size() != 0) {
1898
351
            uint8_t keyState[sizeof_bit_array(KEY_MAX + 1)];
1899
352
            memset(keyState, 0, sizeof(keyState));
1900
353
            if (ioctl(device->fd, EVIOCGKEY(sizeof(keyState)), keyState) >= 0) {
1901
354
                for (size_t i = 0; i < scanCodes.size(); i++) {
1902
355
                    int32_t sc = scanCodes.itemAt(i);
1903
356
                    if (sc >= 0 && sc <= KEY_MAX && test_bit(sc, keyState)) {
1904
357
                        return AKEY_STATE_DOWN;
1905
358
                    }
1906
359
                }
1907
360
                return AKEY_STATE_UP;
1908
361
            }
1909
362
        }
1910
363
    }
1911
364
    return AKEY_STATE_UNKNOWN;
1912
365
}
1913
366
1914
367
int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
1915
368
    if (sw >= 0 && sw <= SW_MAX) {
1916
369
        AutoMutex _l(mLock);
1917
370
1918
371
        Device* device = getDeviceLocked(deviceId);
1919
372
        if (device && !device->isVirtual() && test_bit(sw, device->swBitmask)) {
1920
373
            uint8_t swState[sizeof_bit_array(SW_MAX + 1)];
1921
374
            memset(swState, 0, sizeof(swState));
1922
375
            if (ioctl(device->fd, EVIOCGSW(sizeof(swState)), swState) >= 0) {
1923
376
                return test_bit(sw, swState) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
1924
377
            }
1925
378
        }
1926
379
    }
1927
380
    return AKEY_STATE_UNKNOWN;
1928
381
}
1929
382
1930
383
status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const {
1931
384
    *outValue = 0;
1932
385
1933
386
    if (axis >= 0 && axis <= ABS_MAX) {
1934
387
        AutoMutex _l(mLock);
1935
388
1936
389
        Device* device = getDeviceLocked(deviceId);
1937
390
        if (device && !device->isVirtual() && test_bit(axis, device->absBitmask)) {
1938
391
            struct input_absinfo info;
1939
392
            if(ioctl(device->fd, EVIOCGABS(axis), &info)) {
1940
393
                ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",
1941
394
                     axis, c_str(device->identifier.name), device->fd, errno);
1942
395
                return -errno;
1943
396
            }
1944
397
1945
398
            *outValue = info.value;
1946
399
            return OK;
1947
400
        }
1948
401
    }
1949
402
    return -1;
1950
403
}
1951
404
1952
405
bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
1953
406
        const int32_t* keyCodes, uint8_t* outFlags) const {
1954
407
    AutoMutex _l(mLock);
1955
408
1956
409
    Device* device = getDeviceLocked(deviceId);
1957
410
    if (device && device->keyMap.haveKeyLayout()) {
1958
411
        Vector<int32_t> scanCodes;
1959
412
        for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) {
1960
413
            scanCodes.clear();
1961
414
1962
415
            status_t err = device->keyMap.keyLayoutMap->findScanCodesForKey(
1963
416
                    keyCodes[codeIndex], &scanCodes);
1964
417
            if (! err) {
1965
418
                // check the possible scan codes identified by the layout map against the
1966
419
                // map of codes actually emitted by the driver
1967
420
                for (size_t sc = 0; sc < scanCodes.size(); sc++) {
1968
421
                    if (test_bit(scanCodes[sc], device->keyBitmask)) {
1969
422
                        outFlags[codeIndex] = 1;
1970
423
                        break;
1971
424
                    }
1972
425
                }
1973
426
            }
1974
427
        }
1975
428
        return true;
1976
429
    }
1977
430
    return false;
1978
431
}
1979
432
1980
433
status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
1981
434
        int32_t* outKeycode, uint32_t* outFlags) const {
1982
435
    AutoMutex _l(mLock);
1983
436
    Device* device = getDeviceLocked(deviceId);
1984
437
1985
438
    if (device) {
1986
439
        // Check the key character map first.
1987
440
        sp<KeyCharacterMap> kcm = device->getKeyCharacterMap();
1988
441
        if (kcm != NULL) {
1989
442
            if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {
1990
443
                *outFlags = 0;
1991
444
                return NO_ERROR;
1992
445
            }
1993
446
        }
1994
447
1995
448
        // Check the key layout next.
1996
449
        if (device->keyMap.haveKeyLayout()) {
1997
450
            if (!device->keyMap.keyLayoutMap->mapKey(
1998
451
                    scanCode, usageCode, outKeycode, outFlags)) {
1999
452
                return NO_ERROR;
2000
453
            }
2001
454
        }
2002
455
    }
2003
456
2004
457
    *outKeycode = 0;
2005
458
    *outFlags = 0;
2006
459
    return NAME_NOT_FOUND;
2007
460
}
2008
461
2009
462
status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const {
2010
463
    AutoMutex _l(mLock);
2011
464
    Device* device = getDeviceLocked(deviceId);
2012
465
2013
466
    if (device && device->keyMap.haveKeyLayout()) {
2014
467
        status_t err = device->keyMap.keyLayoutMap->mapAxis(scanCode, outAxisInfo);
2015
468
        if (err == NO_ERROR) {
2016
469
            return NO_ERROR;
2017
470
        }
2018
471
    }
2019
472
2020
473
    return NAME_NOT_FOUND;
2021
474
}
2022
475
2023
476
void EventHub::setExcludedDevices(const Vector<String8>& devices) {
2024
477
    AutoMutex _l(mLock);
2025
478
2026
479
    mExcludedDevices = devices;
2027
480
}
2028
481
2029
482
bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
2030
483
    AutoMutex _l(mLock);
2031
484
    Device* device = getDeviceLocked(deviceId);
2032
485
    if (device && scanCode >= 0 && scanCode <= KEY_MAX) {
2033
486
        if (test_bit(scanCode, device->keyBitmask)) {
2034
487
            return true;
2035
488
        }
2036
489
    }
2037
490
    return false;
2038
491
}
2039
492
2040
493
bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
2041
494
    AutoMutex _l(mLock);
2042
495
    Device* device = getDeviceLocked(deviceId);
2043
496
    if (device && led >= 0 && led <= LED_MAX) {
2044
497
        if (test_bit(led, device->ledBitmask)) {
2045
498
            return true;
2046
499
        }
2047
500
    }
2048
501
    return false;
2049
502
}
2050
503
2051
504
void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) {
2052
505
    AutoMutex _l(mLock);
2053
506
    Device* device = getDeviceLocked(deviceId);
2054
507
    if (device && !device->isVirtual() && led >= 0 && led <= LED_MAX) {
2055
508
        struct input_event ev;
2056
509
        ev.time.tv_sec = 0;
2057
510
        ev.time.tv_usec = 0;
2058
511
        ev.type = EV_LED;
2059
512
        ev.code = led;
2060
513
        ev.value = on ? 1 : 0;
2061
514
2062
515
        ssize_t nWrite;
2063
516
        do {
2064
517
            nWrite = write(device->fd, &ev, sizeof(struct input_event));
2065
518
        } while (nWrite == -1 && errno == EINTR);
2066
519
    }
2067
520
}
2068
521
2069
522
void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
2070
523
        Vector<VirtualKeyDefinition>& outVirtualKeys) const {
2071
524
    outVirtualKeys.clear();
2072
525
2073
526
    AutoMutex _l(mLock);
2074
527
    Device* device = getDeviceLocked(deviceId);
2075
528
    if (device && device->virtualKeyMap) {
2076
529
        outVirtualKeys.appendVector(device->virtualKeyMap->getVirtualKeys());
2077
530
    }
2078
531
}
2079
532
2080
533
sp<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const {
2081
534
    AutoMutex _l(mLock);
2082
535
    Device* device = getDeviceLocked(deviceId);
2083
536
    if (device) {
2084
537
        return device->getKeyCharacterMap();
2085
538
    }
2086
539
    return NULL;
2087
540
}
2088
541
2089
542
bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId,
2090
543
        const sp<KeyCharacterMap>& map) {
2091
544
    AutoMutex _l(mLock);
2092
545
    Device* device = getDeviceLocked(deviceId);
2093
546
    if (device) {
2094
547
        if (map != device->overlayKeyMap) {
2095
548
            device->overlayKeyMap = map;
2096
549
            device->combinedKeyMap = KeyCharacterMap::combine(
2097
550
                    device->keyMap.keyCharacterMap, map);
2098
551
            return true;
2099
552
        }
2100
553
    }
2101
554
    return false;
2102
555
}
2103
556
2104
557
void EventHub::vibrate(int32_t deviceId, std::chrono::nanoseconds duration) {
2105
558
    AutoMutex _l(mLock);
2106
559
    Device* device = getDeviceLocked(deviceId);
2107
560
    if (device && !device->isVirtual()) {
2108
561
        ff_effect effect;
2109
562
        memset(&effect, 0, sizeof(effect));
2110
563
        effect.type = FF_RUMBLE;
2111
564
        effect.id = device->ffEffectId;
2112
565
        effect.u.rumble.strong_magnitude = 0xc000;
2113
566
        effect.u.rumble.weak_magnitude = 0xc000;
2114
567
        effect.replay.length = (duration + std::chrono::nanoseconds(999999)) / std::chrono::nanoseconds(1000000LL);
2115
568
        effect.replay.delay = 0;
2116
569
        if (ioctl(device->fd, EVIOCSFF, &effect)) {
2117
570
            ALOGW("Could not upload force feedback effect to device %s due to error %d.",
2118
571
                c_str(device->identifier.name), errno);
2119
572
            return;
2120
573
        }
2121
574
        device->ffEffectId = effect.id;
2122
575
2123
576
        struct input_event ev;
2124
577
        ev.time.tv_sec = 0;
2125
578
        ev.time.tv_usec = 0;
2126
579
        ev.type = EV_FF;
2127
580
        ev.code = device->ffEffectId;
2128
581
        ev.value = 1;
2129
582
        if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
2130
583
            ALOGW("Could not start force feedback effect on device %s due to error %d.",
2131
584
                c_str(device->identifier.name), errno);
2132
585
            return;
2133
586
        }
2134
587
        device->ffEffectPlaying = true;
2135
588
    }
2136
589
}
2137
590
2138
591
void EventHub::cancelVibrate(int32_t deviceId) {
2139
592
    AutoMutex _l(mLock);
2140
593
    Device* device = getDeviceLocked(deviceId);
2141
594
    if (device && !device->isVirtual()) {
2142
595
        if (device->ffEffectPlaying) {
2143
596
            device->ffEffectPlaying = false;
2144
597
2145
598
            struct input_event ev;
2146
599
            ev.time.tv_sec = 0;
2147
600
            ev.time.tv_usec = 0;
2148
601
            ev.type = EV_FF;
2149
602
            ev.code = device->ffEffectId;
2150
603
            ev.value = 0;
2151
604
            if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
2152
605
                ALOGW("Could not stop force feedback effect on device %s due to error %d.",
2153
606
                    c_str(device->identifier.name), errno);
2154
607
                return;
2155
608
            }
2156
609
        }
2157
610
    }
2158
611
}
2159
612
2160
613
EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const {
2161
614
    if (deviceId == BUILT_IN_KEYBOARD_ID) {
2162
615
        deviceId = mBuiltInKeyboardId;
2163
616
    }
2164
617
    ssize_t index = mDevices.indexOfKey(deviceId);
2165
618
    return index >= 0 ? mDevices.valueAt(index) : NULL;
2166
619
}
2167
620
2168
621
EventHub::Device* EventHub::getDeviceByPathLocked(const char* devicePath) const {
2169
622
    for (size_t i = 0; i < mDevices.size(); i++) {
2170
623
        Device* device = mDevices.valueAt(i);
2171
624
        if (device->path == devicePath) {
2172
625
            return device;
2173
626
        }
2174
627
    }
2175
628
    return NULL;
2176
629
}
2177
630
2178
631
size_t EventHub::getEvents(RawEvent* buffer, size_t bufferSize) {
2179
632
    ALOG_ASSERT(bufferSize >= 1);
2180
633
2181
634
    AutoMutex _l(mLock);
2182
635
2183
636
    struct input_event readBuffer[bufferSize];
2184
637
2185
638
    RawEvent* event = buffer;
2186
639
    size_t capacity = bufferSize;
2187
640
    bool awoken = false;
2188
641
    for (;;) {
2189
642
        std::chrono::nanoseconds now = systemTime(SYSTEM_TIME_MONOTONIC);
2190
643
2191
644
        // Reopen input devices if needed.
2192
645
        if (mNeedToReopenDevices) {
2193
646
            mNeedToReopenDevices = false;
2194
647
2195
648
            ALOGI("Reopening all input devices due to a configuration change.");
2196
649
2197
650
            closeAllDevicesLocked();
2198
651
            mNeedToScanDevices = true;
2199
652
            break; // return to the caller before we actually rescan
2200
653
        }
2201
654
2202
655
        // Report any devices that had last been added/removed.
2203
656
        while (mClosingDevices) {
2204
657
            Device* device = mClosingDevices;
2205
658
            ALOGV("Reporting device closed: id=%d, name=%s\n",
2206
659
                 device->id, c_str(device->path));
2207
660
            mClosingDevices = device->next;
2208
661
            event->when = now;
2209
662
            event->deviceId = device->id == mBuiltInKeyboardId ? BUILT_IN_KEYBOARD_ID : device->id;
2210
663
            event->type = DEVICE_REMOVED;
2211
664
            event += 1;
2212
665
            delete device;
2213
666
            mNeedToSendFinishedDeviceScan = true;
2214
667
            if (--capacity == 0) {
2215
668
                break;
2216
669
            }
2217
670
        }
2218
671
2219
672
        if (mNeedToScanDevices) {
2220
673
            mNeedToScanDevices = false;
2221
674
            scanDevicesLocked();
2222
675
            mNeedToSendFinishedDeviceScan = true;
2223
676
        }
2224
677
2225
678
        while (mOpeningDevices != NULL) {
2226
679
            Device* device = mOpeningDevices;
2227
680
            ALOGV("Reporting device opened: id=%d, name=%s\n",
2228
681
                 device->id, c_str(device->path));
2229
682
            mOpeningDevices = device->next;
2230
683
            event->when = now;
2231
684
            event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
2232
685
            event->type = DEVICE_ADDED;
2233
686
            event += 1;
2234
687
            mNeedToSendFinishedDeviceScan = true;
2235
688
            if (--capacity == 0) {
2236
689
                break;
2237
690
            }
2238
691
        }
2239
692
2240
693
        if (mNeedToSendFinishedDeviceScan) {
2241
694
            mNeedToSendFinishedDeviceScan = false;
2242
695
            event->when = now;
2243
696
            event->type = FINISHED_DEVICE_SCAN;
2244
697
            event += 1;
2245
698
            if (--capacity == 0) {
2246
699
                break;
2247
700
            }
2248
701
        }
2249
702
2250
703
        // Grab the next input event.
2251
704
        bool deviceChanged = false;
2252
705
        while (mPendingEventIndex < mPendingEventCount) {
2253
706
            const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
2254
707
            if (eventItem.data.u32 == EPOLL_ID_UDEV) {
2255
708
                if (eventItem.events & EPOLLIN) {
2256
709
                    mPendingUdevEvent = true;
2257
710
                } else {
2258
711
                    ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
2259
712
                }
2260
713
                continue;
2261
714
            }
2262
715
2263
716
            if (eventItem.data.u32 == EPOLL_ID_WAKE) {
2264
717
                if (eventItem.events & EPOLLIN) {
2265
718
                    ALOGV("awoken after wake()");
2266
719
                    awoken = true;
2267
720
                    char buffer[16];
2268
721
                    ssize_t nRead;
2269
722
                    do {
2270
723
                        nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
2271
724
                    } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
2272
725
                } else {
2273
726
                    ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
2274
727
                            eventItem.events);
2275
728
                }
2276
729
                continue;
2277
730
            }
2278
731
2279
732
            if (eventItem.data.u32 == EPOLL_ID_TIMER) {
2280
733
                if (eventItem.events & EPOLLIN) {
2281
734
                    ALOGV("awoken after wakeIn()");
2282
735
                    awoken = true;
2283
736
                    uint64_t timeout_count;
2284
737
                    read(mTimerFd, &timeout_count, sizeof timeout_count);
2285
738
                } else {
2286
739
                    ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
2287
740
                          eventItem.events);
2288
741
                }
2289
742
                continue;
2290
743
            }
2291
744
2292
745
            ssize_t deviceIndex = mDevices.indexOfKey(eventItem.data.u32);
2293
746
            if (deviceIndex < 0) {
2294
747
                ALOGW("Received unexpected epoll event 0x%08x for unknown device id %d.",
2295
748
                        eventItem.events, eventItem.data.u32);
2296
749
                continue;
2297
750
            }
2298
751
2299
752
            Device* device = mDevices.valueAt(deviceIndex);
2300
753
            if (eventItem.events & EPOLLIN) {
2301
754
                int32_t readSize = read(device->fd, readBuffer,
2302
755
                        sizeof(struct input_event) * capacity);
2303
756
                if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
2304
757
                    // Device was removed before INotify noticed.
2305
758
                    ALOGW("could not get event, removed? (fd: %d size: %d bufferSize: %d "
2306
759
                            "capacity: %d errno: %d)\n",
2307
760
                            device->fd, readSize, bufferSize, capacity, errno);
2308
761
                    deviceChanged = true;
2309
762
                    closeDeviceLocked(device);
2310
763
                } else if (readSize < 0) {
2311
764
                    if (errno != EAGAIN && errno != EINTR) {
2312
765
                        ALOGW("could not get event (errno=%d)", errno);
2313
766
                    }
2314
767
                } else if ((readSize % sizeof(struct input_event)) != 0) {
2315
768
                    ALOGE("could not get event (wrong size: %d)", readSize);
2316
769
                } else {
2317
770
                    int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
2318
771
2319
772
                    size_t count = size_t(readSize) / sizeof(struct input_event);
2320
773
                    for (size_t i = 0; i < count; i++) {
2321
774
                        const struct input_event& iev = readBuffer[i];
2322
775
                        ALOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, value=%d",
2323
776
                            c_str(device->path),
2324
777
                                (int) iev.time.tv_sec, (int) iev.time.tv_usec,
2325
778
                                iev.type, iev.code, iev.value);
2326
779
2327
780
#ifdef HAVE_POSIX_CLOCKS
2328
781
                        // Use the time specified in the event instead of the current time
2329
782
                        // so that downstream code can get more accurate estimates of
2330
783
                        // event dispatch latency from the time the event is enqueued onto
2331
784
                        // the evdev client buffer.
2332
785
                        //
2333
786
                        // The event's timestamp fortuitously uses the same monotonic clock
2334
787
                        // time base as the rest of Android.  The kernel event device driver
2335
788
                        // (drivers/input/evdev.c) obtains timestamps using ktime_get_ts().
2336
789
                        // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
2337
790
                        // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a
2338
791
                        // system call that also queries ktime_get_ts().
2339
792
                        event->when = std::chrono::nanoseconds(iev.time.tv_sec) * 1000000000LL
2340
793
                                + std::chrono::nanoseconds(iev.time.tv_usec) * 1000LL;
2341
794
                        ALOGV("event time %lld, now %lld", event->when, now);
2342
795
#else
2343
796
                        event->when = now;
2344
797
#endif
2345
798
                        event->deviceId = deviceId;
2346
799
                        event->type = iev.type;
2347
800
                        event->code = iev.code;
2348
801
                        event->value = iev.value;
2349
802
2350
803
                        input_report->received_event_from_kernel(event->when.count(), event->type, event->code, event->value);
2351
804
2352
805
                        event += 1;
2353
806
                    }
2354
807
                    capacity -= count;
2355
808
                    if (capacity == 0) {
2356
809
                        // The result buffer is full.  Reset the pending event index
2357
810
                        // so we will try to read the device again on the next iteration.
2358
811
                        mPendingEventIndex -= 1;
2359
812
                        break;
2360
813
                    }
2361
814
                }
2362
815
            } else if (eventItem.events & EPOLLHUP) {
2363
816
                ALOGI("Removing device %s due to epoll hang-up event.",
2364
817
                    c_str(device->identifier.name));
2365
818
                deviceChanged = true;
2366
819
                closeDeviceLocked(device);
2367
820
            } else {
2368
821
                ALOGW("Received unexpected epoll event 0x%08x for device %s.",
2369
822
                        eventItem.events, c_str(device->identifier.name));
2370
823
            }
2371
824
        }
2372
825
2373
826
        // readNotify() will modify the list of devices so this must be done after
2374
827
        // processing all other events to ensure that we read all remaining events
2375
828
        // before closing the devices.
2376
829
        if (mPendingUdevEvent && mPendingEventIndex >= mPendingEventCount) {
2377
830
            mPendingUdevEvent = false;
2378
831
            handleUdevEventsLocked();
2379
832
            deviceChanged = true;
2380
833
        }
2381
834
2382
835
        // Report added or removed devices immediately.
2383
836
        if (deviceChanged) {
2384
837
            continue;
2385
838
        }
2386
839
2387
840
        // Return now if we have collected any events or if we were explicitly awoken.
2388
841
        if (event != buffer || awoken) {
2389
842
            break;
2390
843
        }
2391
844
2392
845
        // Poll for events.  Mind the wake lock dance!
2393
846
        // We hold a wake lock at all times except during epoll_wait().  This works due to some
2394
847
        // subtle choreography.  When a device driver has pending (unread) events, it acquires
2395
848
        // a kernel wake lock.  However, once the last pending event has been read, the device
2396
849
        // driver will release the kernel wake lock.  To prevent the system from going to sleep
2397
850
        // when this happens, the EventHub holds onto its own user wake lock while the client
2398
851
        // is processing events.  Thus the system can only sleep if there are no events
2399
852
        // pending or currently being processed.
2400
853
        mPendingEventIndex = 0;
2401
854
2402
855
        mLock.unlock(); // release lock before poll, must be before release_wake_lock
2403
856
        release_wake_lock(WAKE_LOCK_ID);
2404
857
2405
858
        // non blocking call to epoll_wait - blocking happens in dispatch threads
2406
859
        int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, 0);
2407
860
2408
861
        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
2409
862
        mLock.lock(); // reacquire lock after poll, must be after acquire_wake_lock
2410
863
2411
864
        if (pollResult == 0) {
2412
865
            // Timed out.
2413
866
            mPendingEventCount = 0;
2414
867
            break;
2415
868
        }
2416
869
2417
870
        if (pollResult < 0) {
2418
871
            // An error occurred.
2419
872
            mPendingEventCount = 0;
2420
873
2421
874
            // Sleep after errors to avoid locking up the system.
2422
875
            // Hopefully the error is transient.
2423
876
            if (errno != EINTR) {
2424
877
                ALOGW("poll failed (errno=%d)\n", errno);
2425
878
                usleep(100000);
2426
879
            }
2427
880
        } else {
2428
881
            // Some events occurred.
2429
882
            mPendingEventCount = size_t(pollResult);
2430
883
        }
2431
884
    }
2432
885
2433
886
    // All done, return the number of events we read.
2434
887
    return event - buffer;
2435
888
}
2436
889
2437
890
void EventHub::wakeIn(int32_t timeoutMillis) {
2438
891
    itimerspec delay;
2439
892
    std::memset(&delay, 0, sizeof delay);
2440
893
2441
894
    delay.it_value.tv_sec = timeoutMillis / 1000;
2442
895
    delay.it_value.tv_nsec = (timeoutMillis % 1000) * 1000000LL;
2443
896
    timerfd_settime(mTimerFd, 0, &delay, nullptr);
2444
897
}
2445
898
2446
899
void EventHub::wake() {
2447
900
    ALOGV("wake() called");
2448
901
2449
902
    ssize_t nWrite;
2450
903
    do {
2451
904
        nWrite = write(mWakeWritePipeFd, "W", 1);
2452
905
    } while (nWrite == -1 && errno == EINTR);
2453
906
2454
907
    if (nWrite != 1 && errno != EAGAIN) {
2455
908
        ALOGW("Could not write wake signal, errno=%d", errno);
2456
909
    }
2457
910
}
2458
911
2459
912
void EventHub::scanDevicesLocked() {
2460
913
    mir::udev::Enumerator input_enumerator{std::make_shared<mir::udev::Context>()};
2461
914
2462
915
    input_enumerator.match_subsystem("input");
2463
916
    input_enumerator.scan_devices();
2464
917
2465
918
    for (auto& device : input_enumerator)
2466
919
    {
2467
920
        if (device.devnode() != nullptr)
2468
921
        {
2469
922
            openDeviceLocked(device.devnode());
2470
923
        }
2471
924
    }
2472
925
2473
926
    if (mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID) < 0) {
2474
927
        createVirtualKeyboardLocked();
2475
928
    }
2476
929
}
2477
930
2478
931
void EventHub::handleUdevEventsLocked()
2479
932
{
2480
933
    device_listener->process_events([this](mir::udev::Monitor::EventType type, mir::udev::Device const& dev){
2481
934
        if (type == mir::udev::Monitor::ADDED)
2482
935
        {
2483
936
            if (dev.devnode() != nullptr)
2484
937
            {
2485
938
                openDeviceLocked(dev.devnode());
2486
939
            }
2487
940
        }
2488
941
        else if (type == mir::udev::Monitor::REMOVED)
2489
942
        {
2490
943
            if (dev.devnode() != nullptr)
2491
944
            {
2492
945
                closeDeviceByPathLocked(dev.devnode());
2493
946
            }
2494
947
        }
2495
948
    });
2496
949
}
2497
950
2498
951
// ----------------------------------------------------------------------------
2499
952
2500
953
static bool containsNonZeroByte(const uint8_t* array, uint32_t startIndex, uint32_t endIndex) {
2501
954
    const uint8_t* end = array + endIndex;
2502
955
    array += startIndex;
2503
956
    while (array != end) {
2504
957
        if (*(array++) != 0) {
2505
958
            return true;
2506
959
        }
2507
960
    }
2508
961
    return false;
2509
962
}
2510
963
2511
964
static const int32_t GAMEPAD_KEYCODES[] = {
2512
965
        AKEYCODE_BUTTON_A, AKEYCODE_BUTTON_B, AKEYCODE_BUTTON_C,
2513
966
        AKEYCODE_BUTTON_X, AKEYCODE_BUTTON_Y, AKEYCODE_BUTTON_Z,
2514
967
        AKEYCODE_BUTTON_L1, AKEYCODE_BUTTON_R1,
2515
968
        AKEYCODE_BUTTON_L2, AKEYCODE_BUTTON_R2,
2516
969
        AKEYCODE_BUTTON_THUMBL, AKEYCODE_BUTTON_THUMBR,
2517
970
        AKEYCODE_BUTTON_START, AKEYCODE_BUTTON_SELECT, AKEYCODE_BUTTON_MODE,
2518
971
        AKEYCODE_BUTTON_1, AKEYCODE_BUTTON_2, AKEYCODE_BUTTON_3, AKEYCODE_BUTTON_4,
2519
972
        AKEYCODE_BUTTON_5, AKEYCODE_BUTTON_6, AKEYCODE_BUTTON_7, AKEYCODE_BUTTON_8,
2520
973
        AKEYCODE_BUTTON_9, AKEYCODE_BUTTON_10, AKEYCODE_BUTTON_11, AKEYCODE_BUTTON_12,
2521
974
        AKEYCODE_BUTTON_13, AKEYCODE_BUTTON_14, AKEYCODE_BUTTON_15, AKEYCODE_BUTTON_16,
2522
975
};
2523
976
2524
977
status_t EventHub::openDeviceLocked(const char *devicePath) {
2525
978
    char buffer[80];
2526
979
2527
980
    ALOGV("Opening device: %s", devicePath);
2528
981
    if (hasDeviceByPathLocked(String8(devicePath)))
2529
982
    {
2530
983
        ALOGV("Not opening device (%s), as it is already opened", devicePath);
2531
984
        return -1;
2532
985
    }
2533
986
2534
987
    int fd = open(devicePath, O_RDWR | O_CLOEXEC);
2535
988
    if(fd < 0) {
2536
989
        ALOGE("could not open %s, %s\n", devicePath, strerror(errno));
2537
990
        return -1;
2538
991
    }
2539
992
2540
993
    InputDeviceIdentifier identifier;
2541
994
2542
995
    // Get device name.
2543
996
    if(ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {
2544
997
        //fprintf(stderr, "could not get device name for %s, %s\n", devicePath, strerror(errno));
2545
998
    } else {
2546
999
        buffer[sizeof(buffer) - 1] = '\0';
2547
1000
        setTo(identifier.name, buffer);
2548
1001
    }
2549
1002
2550
1003
    // Check to see if the device is on our excluded list
2551
1004
    for (size_t i = 0; i < mExcludedDevices.size(); i++) {
2552
1005
        const String8& item = mExcludedDevices.itemAt(i);
2553
1006
        if (identifier.name == item) {
2554
1007
            ALOGI("ignoring event id %s driver %s\n", devicePath, c_str(item));
2555
1008
            close(fd);
2556
1009
            return -1;
2557
1010
        }
2558
1011
    }
2559
1012
2560
1013
    // Get device driver version.
2561
1014
    int driverVersion;
2562
1015
    if(ioctl(fd, EVIOCGVERSION, &driverVersion)) {
2563
1016
        ALOGE("could not get driver version for %s, %s\n", devicePath, strerror(errno));
2564
1017
        close(fd);
2565
1018
        return -1;
2566
1019
    }
2567
1020
2568
1021
    // Get device identifier.
2569
1022
    struct input_id inputId;
2570
1023
    if(ioctl(fd, EVIOCGID, &inputId)) {
2571
1024
        ALOGE("could not get device input id for %s, %s\n", devicePath, strerror(errno));
2572
1025
        close(fd);
2573
1026
        return -1;
2574
1027
    }
2575
1028
    identifier.bus = inputId.bustype;
2576
1029
    identifier.product = inputId.product;
2577
1030
    identifier.vendor = inputId.vendor;
2578
1031
    identifier.version = inputId.version;
2579
1032
2580
1033
    // Get device physical location.
2581
1034
    if(ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) {
2582
1035
        //fprintf(stderr, "could not get location for %s, %s\n", devicePath, strerror(errno));
2583
1036
    } else {
2584
1037
        buffer[sizeof(buffer) - 1] = '\0';
2585
1038
        setTo(identifier.location, buffer);
2586
1039
    }
2587
1040
2588
1041
    // Get device unique id.
2589
1042
    if(ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) {
2590
1043
        //fprintf(stderr, "could not get idstring for %s, %s\n", devicePath, strerror(errno));
2591
1044
    } else {
2592
1045
        buffer[sizeof(buffer) - 1] = '\0';
2593
1046
        setTo(identifier.uniqueId, buffer);
2594
1047
    }
2595
1048
2596
1049
    // Fill in the descriptor.
2597
1050
    setDescriptor(identifier);
2598
1051
2599
1052
    // Make file descriptor non-blocking for use with poll().
2600
1053
    if (fcntl(fd, F_SETFL, O_NONBLOCK)) {
2601
1054
        ALOGE("Error %d making device file descriptor non-blocking.", errno);
2602
1055
        close(fd);
2603
1056
        return -1;
2604
1057
    }
2605
1058
2606
1059
    // Allocate device.  (The device object takes ownership of the fd at this point.)
2607
1060
    int32_t deviceId = mNextDeviceId++;
2608
1061
    Device* device = new Device(fd, deviceId, String8(devicePath), identifier);
2609
1062
2610
1063
    ALOGV("add device %d: %s\n", deviceId, devicePath);
2611
1064
    ALOGV("  bus:        %04x\n"
2612
1065
         "  vendor      %04x\n"
2613
1066
         "  product     %04x\n"
2614
1067
         "  version     %04x\n",
2615
1068
        identifier.bus, identifier.vendor, identifier.product, identifier.version);
2616
1069
    ALOGV("  name:       \"%s\"\n", c_str(identifier.name));
2617
1070
    ALOGV("  location:   \"%s\"\n", c_str(identifier.location));
2618
1071
    ALOGV("  unique id:  \"%s\"\n", c_str(identifier.uniqueId));
2619
1072
    ALOGV("  descriptor: \"%s\"\n", c_str(identifier.descriptor));
2620
1073
    ALOGV("  driver:     v%d.%d.%d\n",
2621
1074
        driverVersion >> 16, (driverVersion >> 8) & 0xff, driverVersion & 0xff);
2622
1075
2623
1076
    // Load the configuration file for the device.
2624
1077
    loadConfigurationLocked(device);
2625
1078
2626
1079
    // Figure out the kinds of events the device reports.
2627
1080
    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(device->keyBitmask)), device->keyBitmask);
2628
1081
    ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(device->absBitmask)), device->absBitmask);
2629
1082
    ioctl(fd, EVIOCGBIT(EV_REL, sizeof(device->relBitmask)), device->relBitmask);
2630
1083
    ioctl(fd, EVIOCGBIT(EV_SW, sizeof(device->swBitmask)), device->swBitmask);
2631
1084
    ioctl(fd, EVIOCGBIT(EV_LED, sizeof(device->ledBitmask)), device->ledBitmask);
2632
1085
    ioctl(fd, EVIOCGBIT(EV_FF, sizeof(device->ffBitmask)), device->ffBitmask);
2633
1086
    ioctl(fd, EVIOCGPROP(sizeof(device->propBitmask)), device->propBitmask);
2634
1087
2635
1088
    // See if this is a keyboard.  Ignore everything in the button range except for
2636
1089
    // joystick and gamepad buttons which are handled like keyboards for the most part.
2637
1090
    bool haveKeyboardKeys = containsNonZeroByte(device->keyBitmask, 0, sizeof_bit_array(BTN_MISC))
2638
1091
            || containsNonZeroByte(device->keyBitmask, sizeof_bit_array(KEY_OK),
2639
1092
                    sizeof_bit_array(KEY_MAX + 1));
2640
1093
    bool haveGamepadButtons = containsNonZeroByte(device->keyBitmask, sizeof_bit_array(BTN_MISC),
2641
1094
                    sizeof_bit_array(BTN_MOUSE))
2642
1095
            || containsNonZeroByte(device->keyBitmask, sizeof_bit_array(BTN_JOYSTICK),
2643
1096
                    sizeof_bit_array(BTN_DIGI));
2644
1097
    if (haveKeyboardKeys || haveGamepadButtons) {
2645
1098
        device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;
2646
1099
    }
2647
1100
2648
1101
    // See if this is a cursor device such as a trackball or mouse.
2649
1102
    if (test_bit(BTN_MOUSE, device->keyBitmask)
2650
1103
            && test_bit(REL_X, device->relBitmask)
2651
1104
            && test_bit(REL_Y, device->relBitmask)) {
2652
1105
        device->classes |= INPUT_DEVICE_CLASS_CURSOR;
2653
1106
    }
2654
1107
2655
1108
    // See if this is a touch pad.
2656
1109
    // Is this a new modern multi-touch driver?
2657
1110
    if (test_bit(ABS_MT_POSITION_X, device->absBitmask)
2658
1111
            && test_bit(ABS_MT_POSITION_Y, device->absBitmask)) {
2659
1112
        // Some joysticks such as the PS3 controller report axes that conflict
2660
1113
        // with the ABS_MT range.  Try to confirm that the device really is
2661
1114
        // a touch screen.
2662
1115
        if (test_bit(BTN_TOUCH, device->keyBitmask) || !haveGamepadButtons) {
2663
1116
            device->classes |= INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_TOUCH_MT;
2664
1117
        }
2665
1118
    // Is this an old style single-touch driver?
2666
1119
    } else if (test_bit(BTN_TOUCH, device->keyBitmask)
2667
1120
            && test_bit(ABS_X, device->absBitmask)
2668
1121
            && test_bit(ABS_Y, device->absBitmask)) {
2669
1122
        device->classes |= INPUT_DEVICE_CLASS_TOUCH;
2670
1123
    }
2671
1124
2672
1125
    // See if this device is a joystick.
2673
1126
    // Assumes that joysticks always have gamepad buttons in order to distinguish them
2674
1127
    // from other devices such as accelerometers that also have absolute axes.
2675
1128
    if (haveGamepadButtons) {
2676
1129
        uint32_t assumedClasses = device->classes | INPUT_DEVICE_CLASS_JOYSTICK;
2677
1130
        for (int i = 0; i <= ABS_MAX; i++) {
2678
1131
            if (test_bit(i, device->absBitmask)
2679
1132
                    && (getAbsAxisUsage(i, assumedClasses) & INPUT_DEVICE_CLASS_JOYSTICK)) {
2680
1133
                device->classes = assumedClasses;
2681
1134
                break;
2682
1135
            }
2683
1136
        }
2684
1137
    }
2685
1138
2686
1139
    // Check whether this device has switches.
2687
1140
    for (int i = 0; i <= SW_MAX; i++) {
2688
1141
        if (test_bit(i, device->swBitmask)) {
2689
1142
            device->classes |= INPUT_DEVICE_CLASS_SWITCH;
2690
1143
            break;
2691
1144
        }
2692
1145
    }
2693
1146
2694
1147
    // Check whether this device supports the vibrator.
2695
1148
    if (test_bit(FF_RUMBLE, device->ffBitmask)) {
2696
1149
        device->classes |= INPUT_DEVICE_CLASS_VIBRATOR;
2697
1150
    }
2698
1151
2699
1152
    // Configure virtual keys.
2700
1153
    if ((device->classes & INPUT_DEVICE_CLASS_TOUCH)) {
2701
1154
        // Load the virtual keys for the touch screen, if any.
2702
1155
        // We do this now so that we can make sure to load the keymap if necessary.
2703
1156
        status_t status = loadVirtualKeyMapLocked(device);
2704
1157
        if (!status) {
2705
1158
            device->classes |= INPUT_DEVICE_CLASS_KEYBOARD;
2706
1159
        }
2707
1160
    }
2708
1161
2709
1162
    // Load the key map.
2710
1163
    // We need to do this for joysticks too because the key layout may specify axes.
2711
1164
    status_t keyMapStatus = NAME_NOT_FOUND;
2712
1165
    if (device->classes & (INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_JOYSTICK)) {
2713
1166
        // Load the keymap for the device.
2714
1167
        keyMapStatus = loadKeyMapLocked(device);
2715
1168
    }
2716
1169
2717
1170
    // Configure the keyboard, gamepad or virtual keyboard.
2718
1171
    if (device->classes & INPUT_DEVICE_CLASS_KEYBOARD) {
2719
1172
        // Register the keyboard as a built-in keyboard if it is eligible.
2720
1173
        if (!keyMapStatus
2721
1174
                && mBuiltInKeyboardId == NO_BUILT_IN_KEYBOARD
2722
1175
                && isEligibleBuiltInKeyboard(device->identifier,
2723
1176
                        device->configuration, &device->keyMap)) {
2724
1177
            mBuiltInKeyboardId = device->id;
2725
1178
        }
2726
1179
2727
1180
        // 'Q' key support = cheap test of whether this is an alpha-capable kbd
2728
1181
        if (hasKeycodeLocked(device, AKEYCODE_Q)) {
2729
1182
            device->classes |= INPUT_DEVICE_CLASS_ALPHAKEY;
2730
1183
        }
2731
1184
2732
1185
        // See if this device has a DPAD.
2733
1186
        if (hasKeycodeLocked(device, AKEYCODE_DPAD_UP) &&
2734
1187
                hasKeycodeLocked(device, AKEYCODE_DPAD_DOWN) &&
2735
1188
                hasKeycodeLocked(device, AKEYCODE_DPAD_LEFT) &&
2736
1189
                hasKeycodeLocked(device, AKEYCODE_DPAD_RIGHT) &&
2737
1190
                hasKeycodeLocked(device, AKEYCODE_DPAD_CENTER)) {
2738
1191
            device->classes |= INPUT_DEVICE_CLASS_DPAD;
2739
1192
        }
2740
1193
2741
1194
        // See if this device has a gamepad.
2742
1195
        for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES)/sizeof(GAMEPAD_KEYCODES[0]); i++) {
2743
1196
            if (hasKeycodeLocked(device, GAMEPAD_KEYCODES[i])) {
2744
1197
                device->classes |= INPUT_DEVICE_CLASS_GAMEPAD;
2745
1198
                break;
2746
1199
            }
2747
1200
        }
2748
1201
    }
2749
1202
2750
1203
    // If the device isn't recognized as something we handle, don't monitor it.
2751
1204
    if (device->classes == 0) {
2752
1205
        ALOGV("Dropping device: id=%d, path='%s', name='%s'",
2753
1206
                deviceId, devicePath, c_str(device->identifier.name));
2754
1207
        delete device;
2755
1208
        return -1;
2756
1209
    }
2757
1210
2758
1211
    // Determine whether the device is external or internal.
2759
1212
    if (isExternalDeviceLocked(device)) {
2760
1213
        device->classes |= INPUT_DEVICE_CLASS_EXTERNAL;
2761
1214
    }
2762
1215
2763
1216
    // Register with epoll.
2764
1217
    struct epoll_event eventItem;
2765
1218
    memset(&eventItem, 0, sizeof(eventItem));
2766
1219
    eventItem.events = EPOLLIN;
2767
1220
    eventItem.data.u32 = deviceId;
2768
1221
    if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
2769
1222
        ALOGE("Could not add device fd to epoll instance.  errno=%d", errno);
2770
1223
        delete device;
2771
1224
        return -1;
2772
1225
    }
2773
1226
2774
1227
    // Enable wake-lock behavior on kernels that support it.
2775
1228
    // TODO: Only need this for devices that can really wake the system.
2776
1229
    bool usingSuspendBlockIoctl = !ioctl(fd, EVIOCSSUSPENDBLOCK, 1);
2777
1230
2778
1231
    // Tell the kernel that we want to use the monotonic clock for reporting timestamps
2779
1232
    // associated with input events.  This is important because the input system
2780
1233
    // uses the timestamps extensively and assumes they were recorded using the monotonic
2781
1234
    // clock.
2782
1235
    //
2783
1236
    // In older kernel, before Linux 3.4, there was no way to tell the kernel which
2784
1237
    // clock to use to input event timestamps.  The standard kernel behavior was to
2785
1238
    // record a real time timestamp, which isn't what we want.  Android kernels therefore
2786
1239
    // contained a patch to the evdev_event() function in drivers/input/evdev.c to
2787
1240
    // replace the call to do_gettimeofday() with ktime_get_ts() to cause the monotonic
2788
1241
    // clock to be used instead of the real time clock.
2789
1242
    //
2790
1243
    // As of Linux 3.4, there is a new EVIOCSCLOCKID ioctl to set the desired clock.
2791
1244
    // Therefore, we no longer require the Android-specific kernel patch described above
2792
1245
    // as long as we make sure to set select the monotonic clock.  We do that here.
2793
1246
    int clockId = CLOCK_MONOTONIC;
2794
1247
    bool usingClockIoctl = !ioctl(fd, EVIOCSCLOCKID, &clockId);
2795
1248
2796
1249
    ALOGI("New device: id=%d, fd=%d, path='%s', name='%s', classes=0x%x, "
2797
1250
            "configuration='%s', keyLayout='%s', keyCharacterMap='%s', builtinKeyboard=%s, "
2798
1251
            "usingSuspendBlockIoctl=%s, usingClockIoctl=%s",
2799
1252
         deviceId, fd, devicePath, c_str(device->identifier.name),
2800
1253
         device->classes,
2801
1254
         c_str(device->configurationFile),
2802
1255
         c_str(device->keyMap.keyLayoutFile),
2803
1256
         c_str(device->keyMap.keyCharacterMapFile),
2804
1257
         toString(mBuiltInKeyboardId == deviceId),
2805
1258
         toString(usingSuspendBlockIoctl), toString(usingClockIoctl));
2806
1259
2807
1260
    addDeviceLocked(device);
2808
1261
    return 0;
2809
1262
}
2810
1263
2811
1264
void EventHub::createVirtualKeyboardLocked() {
2812
1265
    InputDeviceIdentifier identifier;
2813
1266
    identifier.name = "Virtual";
2814
1267
    identifier.uniqueId = "<virtual>";
2815
1268
    setDescriptor(identifier);
2816
1269
2817
1270
    Device* device = new Device(-1, VIRTUAL_KEYBOARD_ID, String8("<virtual>"), identifier);
2818
1271
    device->classes = INPUT_DEVICE_CLASS_KEYBOARD
2819
1272
            | INPUT_DEVICE_CLASS_ALPHAKEY
2820
1273
            | INPUT_DEVICE_CLASS_DPAD
2821
1274
            | INPUT_DEVICE_CLASS_VIRTUAL;
2822
1275
    loadKeyMapLocked(device);
2823
1276
    addDeviceLocked(device);
2824
1277
}
2825
1278
2826
1279
void EventHub::addDeviceLocked(Device* device) {
2827
1280
    mDevices.add(device->id, device);
2828
1281
    device->next = mOpeningDevices;
2829
1282
    mOpeningDevices = device;
2830
1283
}
2831
1284
2832
1285
void EventHub::loadConfigurationLocked(Device* device) {
2833
1286
    device->configurationFile = getInputDeviceConfigurationFilePathByDeviceIdentifier(
2834
1287
            device->identifier, INPUT_DEVICE_CONFIGURATION_FILE_TYPE_CONFIGURATION);
2835
1288
    if (isEmpty(device->configurationFile)) {
2836
1289
        ALOGD("No input device configuration file found for device '%s'.",
2837
1290
            c_str(device->identifier.name));
2838
1291
    } else {
2839
1292
        status_t status = PropertyMap::load(device->configurationFile,
2840
1293
                &device->configuration);
2841
1294
        if (status) {
2842
1295
            ALOGE("Error loading input device configuration file for device '%s'.  "
2843
1296
                    "Using default configuration.",
2844
1297
                    c_str(device->identifier.name));
2845
1298
        }
2846
1299
    }
2847
1300
}
2848
1301
2849
1302
status_t EventHub::loadVirtualKeyMapLocked(Device* device) {
2850
1303
    // The virtual key map is supplied by the kernel as a system board property file.
2851
1304
    String8 path;
2852
1305
    path.append("/sys/board_properties/virtualkeys.");
2853
1306
    path.append(device->identifier.name);
2854
1307
    if (access(c_str(path), R_OK)) {
2855
1308
        return NAME_NOT_FOUND;
2856
1309
    }
2857
1310
    return VirtualKeyMap::load(path, &device->virtualKeyMap);
2858
1311
}
2859
1312
2860
1313
status_t EventHub::loadKeyMapLocked(Device* device) {
2861
1314
    // <mir changes>
2862
1315
    status_t status = device->keyMap.load(device->identifier, device->configuration);
2863
1316
    if (status) 
2864
1317
        status = device->keyMap.loadGenericMaps();
2865
1318
2866
1319
    return status;
2867
1320
    // </mir changes>
2868
1321
}
2869
1322
2870
1323
bool EventHub::isExternalDeviceLocked(Device* device) {
2871
1324
    if (device->configuration) {
2872
1325
        bool value;
2873
1326
        if (device->configuration->tryGetProperty(String8("device.internal"), value)) {
2874
1327
            return !value;
2875
1328
        }
2876
1329
    }
2877
1330
    return device->identifier.bus == BUS_USB || device->identifier.bus == BUS_BLUETOOTH;
2878
1331
}
2879
1332
2880
1333
bool EventHub::hasKeycodeLocked(Device* device, int keycode) const {
2881
1334
    if (!device->keyMap.haveKeyLayout()) {
2882
1335
        return false;
2883
1336
    }
2884
1337
    
2885
1338
    Vector<int32_t> scanCodes;
2886
1339
    device->keyMap.keyLayoutMap->findScanCodesForKey(keycode, &scanCodes);
2887
1340
    const size_t N = scanCodes.size();
2888
1341
    for (size_t i=0; i<N && i<=KEY_MAX; i++) {
2889
1342
        int32_t sc = scanCodes.itemAt(i);
2890
1343
        if (sc >= 0 && sc <= KEY_MAX && test_bit(sc, device->keyBitmask)) {
2891
1344
            return true;
2892
1345
        }
2893
1346
    }
2894
1347
    
2895
1348
    return false;
2896
1349
}
2897
1350
2898
1351
status_t EventHub::closeDeviceByPathLocked(const char *devicePath) {
2899
1352
    Device* device = getDeviceByPathLocked(devicePath);
2900
1353
    if (device) {
2901
1354
        closeDeviceLocked(device);
2902
1355
        return 0;
2903
1356
    }
2904
1357
    ALOGV("Remove device: %s not found, device may already have been removed.", devicePath);
2905
1358
    return -1;
2906
1359
}
2907
1360
2908
1361
void EventHub::closeAllDevicesLocked() {
2909
1362
    while (mDevices.size() > 0) {
2910
1363
        closeDeviceLocked(mDevices.valueAt(mDevices.size() - 1));
2911
1364
    }
2912
1365
}
2913
1366
2914
1367
void EventHub::closeDeviceLocked(Device* device) {
2915
1368
    ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=0x%x\n",
2916
1369
        c_str(device->path), c_str(device->identifier.name), device->id,
2917
1370
         device->fd, device->classes);
2918
1371
2919
1372
    if (device->id == mBuiltInKeyboardId) {
2920
1373
        ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this",
2921
1374
            c_str(device->path), mBuiltInKeyboardId);
2922
1375
        mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD;
2923
1376
    }
2924
1377
2925
1378
    if (!device->isVirtual()) {
2926
1379
        if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, device->fd, NULL)) {
2927
1380
            ALOGW("Could not remove device fd from epoll instance.  errno=%d", errno);
2928
1381
        }
2929
1382
    }
2930
1383
2931
1384
    mDevices.removeItem(device->id);
2932
1385
    device->close();
2933
1386
2934
1387
    // Unlink for opening devices list if it is present.
2935
1388
    Device* pred = NULL;
2936
1389
    bool found = false;
2937
1390
    for (Device* entry = mOpeningDevices; entry != NULL; ) {
2938
1391
        if (entry == device) {
2939
1392
            found = true;
2940
1393
            break;
2941
1394
        }
2942
1395
        pred = entry;
2943
1396
        entry = entry->next;
2944
1397
    }
2945
1398
    if (found) {
2946
1399
        // Unlink the device from the opening devices list then delete it.
2947
1400
        // We don't need to tell the client that the device was closed because
2948
1401
        // it does not even know it was opened in the first place.
2949
1402
        ALOGI("Device %s was immediately closed after opening.", c_str(device->path));
2950
1403
        if (pred) {
2951
1404
            pred->next = device->next;
2952
1405
        } else {
2953
1406
            mOpeningDevices = device->next;
2954
1407
        }
2955
1408
        delete device;
2956
1409
    } else {
2957
1410
        // Link into closing devices list.
2958
1411
        // The device will be deleted later after we have informed the client.
2959
1412
        device->next = mClosingDevices;
2960
1413
        mClosingDevices = device;
2961
1414
    }
2962
1415
}
2963
1416
2964
1417
void EventHub::requestReopenDevices() {
2965
1418
    ALOGV("requestReopenDevices() called");
2966
1419
2967
1420
    AutoMutex _l(mLock);
2968
1421
    mNeedToReopenDevices = true;
2969
1422
}
2970
1423
2971
1424
void EventHub::dump(String8& dump) {
2972
1425
    dump.append("Event Hub State:\n");
2973
1426
2974
1427
    { // acquire lock
2975
1428
        AutoMutex _l(mLock);
2976
1429
2977
1430
        appendFormat(dump, INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);
2978
1431
2979
1432
        dump.append(INDENT "Devices:\n");
2980
1433
2981
1434
        for (size_t i = 0; i < mDevices.size(); i++) {
2982
1435
            const Device* device = mDevices.valueAt(i);
2983
1436
            if (mBuiltInKeyboardId == device->id) {
2984
1437
                appendFormat(dump, INDENT2 "%d: %s (aka device 0 - built-in keyboard)\n",
2985
1438
                        device->id, c_str(device->identifier.name));
2986
1439
            } else {
2987
1440
                appendFormat(dump, INDENT2 "%d: %s\n", device->id,
2988
1441
                    c_str(device->identifier.name));
2989
1442
            }
2990
1443
            appendFormat(dump, INDENT3 "Classes: 0x%08x\n", device->classes);
2991
1444
            appendFormat(dump, INDENT3 "Path: %s\n", c_str(device->path));
2992
1445
            appendFormat(dump, INDENT3 "Descriptor: %s\n", c_str(device->identifier.descriptor));
2993
1446
            appendFormat(dump, INDENT3 "Location: %s\n", c_str(device->identifier.location));
2994
1447
            appendFormat(dump, INDENT3 "UniqueId: %s\n", c_str(device->identifier.uniqueId));
2995
1448
            appendFormat(dump, INDENT3 "Identifier: bus=0x%04x, vendor=0x%04x, "
2996
1449
                    "product=0x%04x, version=0x%04x\n",
2997
1450
                    device->identifier.bus, device->identifier.vendor,
2998
1451
                    device->identifier.product, device->identifier.version);
2999
1452
            appendFormat(dump, INDENT3 "KeyLayoutFile: %s\n",
3000
1453
                c_str(device->keyMap.keyLayoutFile));
3001
1454
            appendFormat(dump, INDENT3 "KeyCharacterMapFile: %s\n",
3002
1455
                c_str(device->keyMap.keyCharacterMapFile));
3003
1456
            appendFormat(dump, INDENT3 "ConfigurationFile: %s\n",
3004
1457
                c_str(device->configurationFile));
3005
1458
            appendFormat(dump, INDENT3 "HaveKeyboardLayoutOverlay: %s\n",
3006
1459
                    toString(device->overlayKeyMap != NULL));
3007
1460
        }
3008
1461
    } // release lock
3009
1462
}
3010
1463
3011
1464
void EventHub::monitor() {
3012
1465
    // Acquire and release the lock to ensure that the event hub has not deadlocked.
3013
1466
    mLock.lock();
3014
1467
    mLock.unlock();
3015
1468
}
3016
1469
3017
1470
void EventHub::flush() {
3018
1471
    static const int bufferSize = 256;
3019
1472
3020
1473
    AutoMutex _l(mLock);
3021
1474
3022
1475
    char readBuffer[bufferSize];
3023
1476
    int32_t readSize;
3024
1477
3025
1478
    // Read any pending events from the input devices. Note that
3026
1479
    // the device fds are in non-blocking mode (see openDeviceLocked).
3027
1480
    for (size_t i = 0; i < mDevices.size(); i++) {
3028
1481
        const Device* device = mDevices.valueAt(i);
3029
1482
        do {
3030
1483
            readSize = read(device->fd, readBuffer, bufferSize);
3031
1484
        } while (readSize > 0);
3032
1485
    }
3033
1486
}
3034
1487
3035
1488
bool EventHub::hasDeviceByPathLocked(String8 const& path)
3036
1489
{
3037
1490
    for (size_t i = 0; i < mDevices.size(); i++) {
3038
1491
        auto const& device = mDevices.valueAt(i);
3039
1492
        if (device->path == path) return true;
3040
1493
    }
3041
1494
    return false;
3042
1495
}
3043
1496
3044
1497
mir::Fd EventHub::fd()
3045
1498
{
3046
1499
    return mEpollFd;
3047
1500
}
3048
1501
3049
1502
}; // namespace android
3050
1503
0
3051
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/EventHub.h'
3052
--- 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	2015-06-17 05:20:42 +0000
3053
+++ 3rd_party/android-input/android/frameworks/base/services/input/EventHub.h	1970-01-01 00:00:00 +0000
3054
@@ -1,444 +0,0 @@
3055
1
/*
3056
2
 * Copyright (C) 2005 The Android Open Source Project
3057
3
 *
3058
4
 * Licensed under the Apache License, Version 2.0 (the "License");
3059
5
 * you may not use this file except in compliance with the License.
3060
6
 * You may obtain a copy of the License at
3061
7
 *
3062
8
 *      http://www.apache.org/licenses/LICENSE-2.0
3063
9
 *
3064
10
 * Unless required by applicable law or agreed to in writing, software
3065
11
 * distributed under the License is distributed on an "AS IS" BASIS,
3066
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3067
13
 * See the License for the specific language governing permissions and
3068
14
 * limitations under the License.
3069
15
 */
3070
16
3071
17
//
3072
18
#ifndef _RUNTIME_EVENT_HUB_H
3073
19
#define _RUNTIME_EVENT_HUB_H
3074
20
3075
21
#include <androidfw/Input.h>
3076
22
#include <androidfw/InputDevice.h>
3077
23
#include <androidfw/Keyboard.h>
3078
24
#include <androidfw/KeyLayoutMap.h>
3079
25
#include <androidfw/KeyCharacterMap.h>
3080
26
#include <androidfw/VirtualKeyMap.h>
3081
27
#include <std/String8.h>
3082
28
#include <std/Mutex.h>
3083
29
#include <std/List.h>
3084
30
#include <std/Errors.h>
3085
31
#include <std/PropertyMap.h>
3086
32
#include <std/Vector.h>
3087
33
#include <std/KeyedVector.h>
3088
34
3089
35
#include "mir/fd.h"
3090
36
3091
37
#include <linux/input.h>
3092
38
#include <sys/epoll.h>
3093
39
3094
40
#include <memory>
3095
41
3096
42
namespace mir
3097
43
{
3098
44
namespace udev { class Monitor; }
3099
45
namespace input
3100
46
{
3101
47
class InputReport;
3102
48
}
3103
49
}
3104
50
3105
51
/* Convenience constants. */
3106
52
3107
53
#define BTN_FIRST 0x100  // first button code
3108
54
#define BTN_LAST 0x15f   // last button code
3109
55
3110
56
namespace android {
3111
57
3112
58
enum {
3113
59
    // Device id of a special "virtual" keyboard that is always present.
3114
60
    VIRTUAL_KEYBOARD_ID = -1,
3115
61
    // Device id of the "built-in" keyboard if there is one.
3116
62
    BUILT_IN_KEYBOARD_ID = 0
3117
63
};
3118
64
3119
65
/*
3120
66
 * A raw event as retrieved from the EventHub.
3121
67
 */
3122
68
struct RawEvent {
3123
69
    std::chrono::nanoseconds when;
3124
70
    int32_t deviceId;
3125
71
    int32_t type;
3126
72
    int32_t code;
3127
73
    int32_t value;
3128
74
};
3129
75
3130
76
/* Describes an absolute axis. */
3131
77
struct RawAbsoluteAxisInfo {
3132
78
    bool valid; // true if the information is valid, false otherwise
3133
79
3134
80
    int32_t minValue;  // minimum value
3135
81
    int32_t maxValue;  // maximum value
3136
82
    int32_t flat;      // center flat position, eg. flat == 8 means center is between -8 and 8
3137
83
    int32_t fuzz;      // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise
3138
84
    int32_t resolution; // resolution in units per mm or radians per mm
3139
85
3140
86
    inline void clear() {
3141
87
        valid = false;
3142
88
        minValue = 0;
3143
89
        maxValue = 0;
3144
90
        flat = 0;
3145
91
        fuzz = 0;
3146
92
        resolution = 0;
3147
93
    }
3148
94
};
3149
95
3150
96
/*
3151
97
 * Input device classes.
3152
98
 */
3153
99
enum {
3154
100
    /* The input device is a keyboard or has buttons. */
3155
101
    INPUT_DEVICE_CLASS_KEYBOARD      = 0x00000001,
3156
102
3157
103
    /* The input device is an alpha-numeric keyboard (not just a dial pad). */
3158
104
    INPUT_DEVICE_CLASS_ALPHAKEY      = 0x00000002,
3159
105
3160
106
    /* The input device is a touchscreen or a touchpad (either single-touch or multi-touch). */
3161
107
    INPUT_DEVICE_CLASS_TOUCH         = 0x00000004,
3162
108
3163
109
    /* The input device is a cursor device such as a trackball or mouse. */
3164
110
    INPUT_DEVICE_CLASS_CURSOR        = 0x00000008,
3165
111
3166
112
    /* The input device is a multi-touch touchscreen. */
3167
113
    INPUT_DEVICE_CLASS_TOUCH_MT      = 0x00000010,
3168
114
3169
115
    /* The input device is a directional pad (implies keyboard, has DPAD keys). */
3170
116
    INPUT_DEVICE_CLASS_DPAD          = 0x00000020,
3171
117
3172
118
    /* The input device is a gamepad (implies keyboard, has BUTTON keys). */
3173
119
    INPUT_DEVICE_CLASS_GAMEPAD       = 0x00000040,
3174
120
3175
121
    /* The input device has switches. */
3176
122
    INPUT_DEVICE_CLASS_SWITCH        = 0x00000080,
3177
123
3178
124
    /* The input device is a joystick (implies gamepad, has joystick absolute axes). */
3179
125
    INPUT_DEVICE_CLASS_JOYSTICK      = 0x00000100,
3180
126
3181
127
    /* The input device has a vibrator (supports FF_RUMBLE). */
3182
128
    INPUT_DEVICE_CLASS_VIBRATOR      = 0x00000200,
3183
129
3184
130
    /* The input device is virtual (not a real device, not part of UI configuration). */
3185
131
    INPUT_DEVICE_CLASS_VIRTUAL       = 0x40000000,
3186
132
3187
133
    /* The input device is external (not built-in). */
3188
134
    INPUT_DEVICE_CLASS_EXTERNAL      = 0x80000000
3189
135
};
3190
136
3191
137
/*
3192
138
 * Gets the class that owns an axis, in cases where multiple classes might claim
3193
139
 * the same axis for different purposes.
3194
140
 */
3195
141
extern uint32_t getAbsAxisUsage(int32_t axis, uint32_t deviceClasses);
3196
142
3197
143
/*
3198
144
 * Grand Central Station for events.
3199
145
 *
3200
146
 * The event hub aggregates input events received across all known input
3201
147
 * devices on the system, including devices that may be emulated by the simulator
3202
148
 * environment.  In addition, the event hub generates fake input events to indicate
3203
149
 * when devices are added or removed.
3204
150
 *
3205
151
 * The event hub provides a stream of input events (via the getEvent function).
3206
152
 * It also supports querying the current actual state of input devices such as identifying
3207
153
 * which keys are currently down.  Finally, the event hub keeps track of the capabilities of
3208
154
 * individual input devices, such as their class and the set of key codes that they support.
3209
155
 */
3210
156
class EventHubInterface : public virtual RefBase {
3211
157
protected:
3212
158
    EventHubInterface() { }
3213
159
    virtual ~EventHubInterface() { }
3214
160
3215
161
public:
3216
162
    // Synthetic raw event type codes produced when devices are added or removed.
3217
163
    enum {
3218
164
        // Sent when a device is added.
3219
165
        DEVICE_ADDED = 0x10000000,
3220
166
        // Sent when a device is removed.
3221
167
        DEVICE_REMOVED = 0x20000000,
3222
168
        // Sent when all added/removed devices from the most recent scan have been reported.
3223
169
        // This event is always sent at least once.
3224
170
        FINISHED_DEVICE_SCAN = 0x30000000,
3225
171
3226
172
        FIRST_SYNTHETIC_EVENT = DEVICE_ADDED
3227
173
    };
3228
174
3229
175
    virtual uint32_t getDeviceClasses(int32_t deviceId) const = 0;
3230
176
3231
177
    virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const = 0;
3232
178
3233
179
    virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const = 0;
3234
180
3235
181
    virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
3236
182
            RawAbsoluteAxisInfo* outAxisInfo) const = 0;
3237
183
3238
184
    virtual bool hasRelativeAxis(int32_t deviceId, int axis) const = 0;
3239
185
3240
186
    virtual bool hasInputProperty(int32_t deviceId, int property) const = 0;
3241
187
3242
188
    virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
3243
189
            int32_t* outKeycode, uint32_t* outFlags) const = 0;
3244
190
3245
191
    virtual status_t mapAxis(int32_t deviceId, int32_t scanCode,
3246
192
            AxisInfo* outAxisInfo) const = 0;
3247
193
3248
194
    // Sets devices that are excluded from opening.
3249
195
    // This can be used to ignore input devices for sensors.
3250
196
    virtual void setExcludedDevices(const Vector<String8>& devices) = 0;
3251
197
3252
198
    /*
3253
199
     * Tests for available events and returns them.
3254
200
     * After returning, the EventHub holds onto a wake lock until the next call to getEvent.
3255
201
     * This ensures that the device will not go to sleep while the event is being processed.
3256
202
     * If the device needs to remain awake longer than that, then the caller is responsible
3257
203
     * for taking care of it (say, by poking the power manager user activity timer).
3258
204
     *
3259
205
     * Returns the number of events obtained.
3260
206
     */
3261
207
    virtual size_t getEvents(RawEvent* buffer, size_t bufferSize) = 0;
3262
208
3263
209
    /*
3264
210
     * Query current input state.
3265
211
     */
3266
212
    virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const = 0;
3267
213
    virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const = 0;
3268
214
    virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const = 0;
3269
215
    virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
3270
216
            int32_t* outValue) const = 0;
3271
217
3272
218
    /*
3273
219
     * Examine key input devices for specific framework keycode support
3274
220
     */
3275
221
    virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
3276
222
            uint8_t* outFlags) const = 0;
3277
223
3278
224
    virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const = 0;
3279
225
    virtual bool hasLed(int32_t deviceId, int32_t led) const = 0;
3280
226
    virtual void setLedState(int32_t deviceId, int32_t led, bool on) = 0;
3281
227
3282
228
    virtual void getVirtualKeyDefinitions(int32_t deviceId,
3283
229
            Vector<VirtualKeyDefinition>& outVirtualKeys) const = 0;
3284
230
3285
231
    virtual sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const = 0;
3286
232
    virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map) = 0;
3287
233
3288
234
    /* Control the vibrator. */
3289
235
    virtual void vibrate(int32_t deviceId, std::chrono::nanoseconds duration) = 0;
3290
236
    virtual void cancelVibrate(int32_t deviceId) = 0;
3291
237
3292
238
    /* Requests the EventHub to reopen all input devices on the next call to getEvents(). */
3293
239
    virtual void requestReopenDevices() = 0;
3294
240
3295
241
    /* Wakes up getEvents() if it is blocked on a read. */
3296
242
    virtual void wake() = 0;
3297
243
3298
244
    /* Ensures that fd() readable after given timeout */
3299
245
    virtual void wakeIn(int32_t timeout) = 0;
3300
246
3301
247
    /* Dump EventHub state to a string. */
3302
248
    virtual void dump(String8& dump) = 0;
3303
249
3304
250
    /* Called by the heatbeat to ensures that the reader has not deadlocked. */
3305
251
    virtual void monitor() = 0;
3306
252
3307
253
    /* Flush all pending events not yet read from the input devices */
3308
254
    virtual void flush() = 0;
3309
255
3310
256
    /* Epoll fd used by EventHub */
3311
257
    virtual mir::Fd fd() = 0;
3312
258
};
3313
259
3314
260
class EventHub : public EventHubInterface
3315
261
{
3316
262
public:
3317
263
    EventHub(std::shared_ptr<mir::input::InputReport> const& input_report);
3318
264
3319
265
    virtual uint32_t getDeviceClasses(int32_t deviceId) const;
3320
266
3321
267
    virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const;
3322
268
3323
269
    virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const;
3324
270
3325
271
    virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
3326
272
            RawAbsoluteAxisInfo* outAxisInfo) const;
3327
273
3328
274
    virtual bool hasRelativeAxis(int32_t deviceId, int axis) const;
3329
275
3330
276
    virtual bool hasInputProperty(int32_t deviceId, int property) const;
3331
277
3332
278
    virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
3333
279
            int32_t* outKeycode, uint32_t* outFlags) const;
3334
280
3335
281
    virtual status_t mapAxis(int32_t deviceId, int32_t scanCode,
3336
282
            AxisInfo* outAxisInfo) const;
3337
283
3338
284
    virtual void setExcludedDevices(const Vector<String8>& devices);
3339
285
3340
286
    virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const;
3341
287
    virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const;
3342
288
    virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const;
3343
289
    virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const;
3344
290
3345
291
    virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
3346
292
            const int32_t* keyCodes, uint8_t* outFlags) const;
3347
293
3348
294
    virtual size_t getEvents(RawEvent* buffer, size_t bufferSize);
3349
295
3350
296
    virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const;
3351
297
    virtual bool hasLed(int32_t deviceId, int32_t led) const;
3352
298
    virtual void setLedState(int32_t deviceId, int32_t led, bool on);
3353
299
3354
300
    virtual void getVirtualKeyDefinitions(int32_t deviceId,
3355
301
            Vector<VirtualKeyDefinition>& outVirtualKeys) const;
3356
302
3357
303
    virtual sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const;
3358
304
    virtual bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map);
3359
305
3360
306
    virtual void vibrate(int32_t deviceId, std::chrono::nanoseconds duration);
3361
307
    virtual void cancelVibrate(int32_t deviceId);
3362
308
3363
309
    virtual void requestReopenDevices();
3364
310
3365
311
    virtual void wake();
3366
312
    virtual void wakeIn(int32_t timeout);
3367
313
3368
314
    virtual void dump(String8& dump);
3369
315
    virtual void monitor();
3370
316
    virtual void flush();
3371
317
    virtual mir::Fd fd();
3372
318
3373
319
    virtual ~EventHub();
3374
320
3375
321
    // Ids used for epoll notifications not associated with devices.
3376
322
    static const uint32_t EPOLL_ID_UDEV = 0x80000001;
3377
323
    static const uint32_t EPOLL_ID_WAKE = 0x80000002;
3378
324
    static const uint32_t EPOLL_ID_TIMER = 0x80000003;
3379
325
private:
3380
326
    std::shared_ptr<mir::input::InputReport> const input_report;
3381
327
3382
328
    struct Device {
3383
329
        Device* next;
3384
330
3385
331
        int fd; // may be -1 if device is virtual
3386
332
        const int32_t id;
3387
333
        const String8 path;
3388
334
        const InputDeviceIdentifier identifier;
3389
335
3390
336
        uint32_t classes;
3391
337
3392
338
        uint8_t keyBitmask[(KEY_MAX + 1) / 8];
3393
339
        uint8_t absBitmask[(ABS_MAX + 1) / 8];
3394
340
        uint8_t relBitmask[(REL_MAX + 1) / 8];
3395
341
        uint8_t swBitmask[(SW_MAX + 1) / 8];
3396
342
        uint8_t ledBitmask[(LED_MAX + 1) / 8];
3397
343
        uint8_t ffBitmask[(FF_MAX + 1) / 8];
3398
344
        uint8_t propBitmask[(INPUT_PROP_MAX + 1) / 8];
3399
345
3400
346
        String8 configurationFile;
3401
347
        PropertyMap* configuration;
3402
348
        VirtualKeyMap* virtualKeyMap;
3403
349
        KeyMap keyMap;
3404
350
3405
351
        sp<KeyCharacterMap> overlayKeyMap;
3406
352
        sp<KeyCharacterMap> combinedKeyMap;
3407
353
3408
354
        bool ffEffectPlaying;
3409
355
        int16_t ffEffectId; // initially -1
3410
356
3411
357
        Device(int fd, int32_t id, const String8& path, const InputDeviceIdentifier& identifier);
3412
358
        ~Device();
3413
359
3414
360
        void close();
3415
361
3416
362
        inline bool isVirtual() const { return fd < 0; }
3417
363
3418
364
        const sp<KeyCharacterMap>& getKeyCharacterMap() const {
3419
365
            if (combinedKeyMap != NULL) {
3420
366
                return combinedKeyMap;
3421
367
            }
3422
368
            return keyMap.keyCharacterMap;
3423
369
        }
3424
370
    };
3425
371
3426
372
    status_t openDeviceLocked(const char *devicePath);
3427
373
    void createVirtualKeyboardLocked();
3428
374
    void addDeviceLocked(Device* device);
3429
375
3430
376
    status_t closeDeviceByPathLocked(const char *devicePath);
3431
377
    void closeDeviceLocked(Device* device);
3432
378
    void closeAllDevicesLocked();
3433
379
3434
380
    void scanDevicesLocked();
3435
381
    void handleUdevEventsLocked();
3436
382
3437
383
    Device* getDeviceLocked(int32_t deviceId) const;
3438
384
    Device* getDeviceByPathLocked(const char* devicePath) const;
3439
385
3440
386
    bool hasKeycodeLocked(Device* device, int keycode) const;
3441
387
3442
388
    void loadConfigurationLocked(Device* device);
3443
389
    status_t loadVirtualKeyMapLocked(Device* device);
3444
390
    status_t loadKeyMapLocked(Device* device);
3445
391
3446
392
    bool isExternalDeviceLocked(Device* device);
3447
393
3448
394
    // Protect all internal state.
3449
395
    mutable Mutex mLock;
3450
396
3451
397
    // The actual id of the built-in keyboard, or NO_BUILT_IN_KEYBOARD if none.
3452
398
    // EventHub remaps the built-in keyboard to id 0 externally as required by the API.
3453
399
    enum {
3454
400
        // Must not conflict with any other assigned device ids, including
3455
401
        // the virtual keyboard id (-1).
3456
402
        NO_BUILT_IN_KEYBOARD = -2
3457
403
    };
3458
404
    int32_t mBuiltInKeyboardId;
3459
405
3460
406
    int32_t mNextDeviceId;
3461
407
3462
408
    bool hasDeviceByPathLocked(String8 const& path);
3463
409
    KeyedVector<int32_t, Device*> mDevices;
3464
410
3465
411
    Device *mOpeningDevices;
3466
412
    Device *mClosingDevices;
3467
413
3468
414
    bool mNeedToSendFinishedDeviceScan;
3469
415
    bool mNeedToReopenDevices;
3470
416
    bool mNeedToScanDevices;
3471
417
    Vector<String8> mExcludedDevices;
3472
418
3473
419
    mir::Fd mEpollFd;
3474
420
    mir::Fd mTimerFd;
3475
421
    std::unique_ptr<mir::udev::Monitor> const device_listener;
3476
422
    int mWakeReadPipeFd;
3477
423
    int mWakeWritePipeFd;
3478
424
3479
425
    // Epoll FD list size hint.
3480
426
    static const int EPOLL_SIZE_HINT = 8;
3481
427
3482
428
    // Maximum number of signalled FDs to handle at a time.
3483
429
    static const int EPOLL_MAX_EVENTS = 16;
3484
430
3485
431
    // The array of pending epoll events and the index of the next event to be handled.
3486
432
    struct epoll_event mPendingEventItems[EPOLL_MAX_EVENTS];
3487
433
    size_t mPendingEventCount;
3488
434
    size_t mPendingEventIndex;
3489
435
    bool mPendingUdevEvent;
3490
436
};
3491
437
3492
438
// Made available to test
3493
439
namespace detail { String8 sha1(const String8& in); }
3494
440
3495
441
3496
442
} // namespace android
3497
443
3498
444
#endif // _RUNTIME_EVENT_HUB_H
3499
445
0
3500
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/GenericKeyMap.cpp'
3501
--- 3rd_party/android-input/android/frameworks/base/services/input/GenericKeyMap.cpp	2013-02-05 17:19:57 +0000
3502
+++ 3rd_party/android-input/android/frameworks/base/services/input/GenericKeyMap.cpp	1970-01-01 00:00:00 +0000
3503
@@ -1,1009 +0,0 @@
3504
1
// Copyright (C) 2010 The Android Open Source Project
3505
2
//
3506
3
// Licensed under the Apache License, Version 2.0 (the "License");
3507
4
// you may not use this file except in compliance with the License.
3508
5
// You may obtain a copy of the License at
3509
6
//
3510
7
//      http://www.apache.org/licenses/LICENSE-2.0
3511
8
//
3512
9
// Unless required by applicable law or agreed to in writing, software
3513
10
// distributed under the License is distributed on an "AS IS" BASIS,
3514
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3515
12
// See the License for the specific language governing permissions and
3516
13
// limitations under the License.
3517
14
//
3518
15
3519
16
#include <androidfw/GenericKeyMap.h>
3520
17
3521
18
const char* android::GenericKeyMap::key_layout_contents()
3522
19
{
3523
20
    static const char* result = 
3524
21
            "key 1     ESCAPE\n"                \
3525
22
            "key 2     1\n"                     \
3526
23
            "key 3     2\n"                     \
3527
24
            "key 4     3\n"                     \
3528
25
            "key 5     4\n"                     \
3529
26
            "key 6     5\n"                     \
3530
27
            "key 7     6\n"                     \
3531
28
            "key 8     7\n"                     \
3532
29
            "key 9     8\n"                     \
3533
30
            "key 10    9\n"                     \
3534
31
            "key 11    0\n"                     \
3535
32
            "key 12    MINUS\n"                 \
3536
33
            "key 13    EQUALS\n"                \
3537
34
            "key 14    DEL\n"                   \
3538
35
            "key 15    TAB\n"                   \
3539
36
            "key 16    Q\n"                     \
3540
37
            "key 17    W\n"                     \
3541
38
            "key 18    E\n"                     \
3542
39
            "key 19    R\n"                     \
3543
40
            "key 20    T\n"                     \
3544
41
            "key 21    Y\n"                     \
3545
42
            "key 22    U\n"                     \
3546
43
            "key 23    I\n"                     \
3547
44
            "key 24    O\n"                     \
3548
45
            "key 25    P\n"                     \
3549
46
            "key 26    LEFT_BRACKET\n"          \
3550
47
            "key 27    RIGHT_BRACKET\n"         \
3551
48
            "key 28    ENTER\n"                 \
3552
49
            "key 29    CTRL_LEFT\n"             \
3553
50
            "key 30    A\n"                     \
3554
51
            "key 31    S\n"                     \
3555
52
            "key 32    D\n"                     \
3556
53
            "key 33    F\n"                     \
3557
54
            "key 34    G\n" \
3558
55
            "key 35    H\n" \
3559
56
            "key 36    J\n" \
3560
57
            "key 37    K\n" \
3561
58
            "key 38    L\n" \
3562
59
            "key 39    SEMICOLON\n" \
3563
60
            "key 40    APOSTROPHE\n" \
3564
61
            "key 41    GRAVE\n" \
3565
62
            "key 42    SHIFT_LEFT\n" \
3566
63
            "key 43    BACKSLASH\n" \
3567
64
            "key 44    Z\n" \
3568
65
            "key 45    X\n" \
3569
66
            "key 46    C\n" \
3570
67
            "key 47    V\n" \
3571
68
            "key 48    B\n" \
3572
69
            "key 49    N\n" \
3573
70
            "key 50    M\n" \
3574
71
            "key 51    COMMA\n" \
3575
72
            "key 52    PERIOD\n" \
3576
73
            "key 53    SLASH\n" \
3577
74
            "key 54    SHIFT_RIGHT\n" \
3578
75
            "key 55    NUMPAD_MULTIPLY\n" \
3579
76
            "key 56    ALT_LEFT\n" \
3580
77
            "key 57    SPACE\n" \
3581
78
            "key 58    CAPS_LOCK\n" \
3582
79
            "key 59    F1\n" \
3583
80
            "key 60    F2\n" \
3584
81
            "key 61    F3\n" \
3585
82
            "key 62    F4\n" \
3586
83
            "key 63    F5\n" \
3587
84
            "key 64    F6\n" \
3588
85
            "key 65    F7\n" \
3589
86
            "key 66    F8\n" \
3590
87
            "key 67    F9\n" \
3591
88
            "key 68    F10\n" \
3592
89
            "key 69    NUM_LOCK\n" \
3593
90
            "key 70    SCROLL_LOCK\n" \
3594
91
            "key 71    NUMPAD_7\n" \
3595
92
            "key 72    NUMPAD_8\n" \
3596
93
            "key 73    NUMPAD_9\n" \
3597
94
            "key 74    NUMPAD_SUBTRACT\n" \
3598
95
            "key 75    NUMPAD_4\n" \
3599
96
            "key 76    NUMPAD_5\n" \
3600
97
            "key 77    NUMPAD_6\n" \
3601
98
            "key 78    NUMPAD_ADD\n" \
3602
99
            "key 79    NUMPAD_1\n" \
3603
100
            "key 80    NUMPAD_2\n" \
3604
101
            "key 81    NUMPAD_3\n" \
3605
102
            "key 82    NUMPAD_0\n" \
3606
103
            "key 83    NUMPAD_DOT\n" \
3607
104
            "# key 84 (undefined)\n" \
3608
105
            "key 85    ZENKAKU_HANKAKU\n" \
3609
106
            "key 86    BACKSLASH\n" \
3610
107
            "key 87    F11\n" \
3611
108
            "key 88    F12\n" \
3612
109
            "key 89    RO\n" \
3613
110
            "# key 90 \"KEY_KATAKANA\"\n" \
3614
111
            "# key 91 \"KEY_HIRAGANA\"\n" \
3615
112
            "key 92    HENKAN\n" \
3616
113
            "key 93    KATAKANA_HIRAGANA\n" \
3617
114
            "key 94    MUHENKAN\n" \
3618
115
            "key 95    NUMPAD_COMMA\n" \
3619
116
            "key 96    NUMPAD_ENTER\n" \
3620
117
            "key 97    CTRL_RIGHT\n" \
3621
118
            "key 98    NUMPAD_DIVIDE\n" \
3622
119
            "key 99    SYSRQ\n" \
3623
120
            "key 100   ALT_RIGHT\n" \
3624
121
            "# key 101 \"KEY_LINEFEED\"\n" \
3625
122
            "key 102   MOVE_HOME\n" \
3626
123
            "key 103   DPAD_UP\n" \
3627
124
            "key 104   PAGE_UP\n" \
3628
125
            "key 105   DPAD_LEFT\n" \
3629
126
            "key 106   DPAD_RIGHT\n" \
3630
127
            "key 107   MOVE_END\n" \
3631
128
            "key 108   DPAD_DOWN\n" \
3632
129
            "key 109   PAGE_DOWN\n" \
3633
130
            "key 110   INSERT\n" \
3634
131
            "key 111   FORWARD_DEL\n" \
3635
132
            "# key 112 \"KEY_MACRO\"\n" \
3636
133
            "key 113   VOLUME_MUTE\n" \
3637
134
            "key 114   VOLUME_DOWN\n" \
3638
135
            "key 115   VOLUME_UP\n" \
3639
136
            "key 116   POWER             WAKE\n" \
3640
137
            "key 117   NUMPAD_EQUALS\n" \
3641
138
            "# key 118 \"KEY_KPPLUSMINUS\"\n" \
3642
139
            "key 119   BREAK\n" \
3643
140
            "# key 120 (undefined)\n" \
3644
141
            "key 121   NUMPAD_COMMA\n" \
3645
142
            "key 122   KANA\n" \
3646
143
            "key 123   EISU\n" \
3647
144
            "key 124   YEN\n" \
3648
145
            "key 125   META_LEFT\n" \
3649
146
            "key 126   META_RIGHT\n" \
3650
147
            "key 127   MENU              WAKE_DROPPED\n" \
3651
148
            "key 128   MEDIA_STOP\n" \
3652
149
            "# key 129 \"KEY_AGAIN\"\n" \
3653
150
            "# key 130 \"KEY_PROPS\"\n" \
3654
151
            "# key 131 \"KEY_UNDO\"\n" \
3655
152
            "# key 132 \"KEY_FRONT\"\n" \
3656
153
            "# key 133 \"KEY_COPY\"\n" \
3657
154
            "# key 134 \"KEY_OPEN\"\n" \
3658
155
            "# key 135 \"KEY_PASTE\"\n" \
3659
156
            "# key 136 \"KEY_FIND\"\n" \
3660
157
            "# key 137 \"KEY_CUT\"\n" \
3661
158
            "# key 138 \"KEY_HELP\"\n" \
3662
159
            "key 139   MENU              WAKE_DROPPED\n" \
3663
160
            "key 140   CALCULATOR\n" \
3664
161
            "# key 141 \"KEY_SETUP\"\n" \
3665
162
            "key 142   POWER             WAKE\n" \
3666
163
            "key 143   POWER             WAKE\n" \
3667
164
            "# key 144 \"KEY_FILE\"\n" \
3668
165
            "# key 145 \"KEY_SENDFILE\"\n" \
3669
166
            "# key 146 \"KEY_DELETEFILE\"\n" \
3670
167
            "# key 147 \"KEY_XFER\"\n" \
3671
168
            "# key 148 \"KEY_PROG1\"\n" \
3672
169
            "# key 149 \"KEY_PROG2\"\n" \
3673
170
            "key 150   EXPLORER\n" \
3674
171
            "# key 151 \"KEY_MSDOS\"\n" \
3675
172
            "key 152   POWER             WAKE\n" \
3676
173
            "# key 153 \"KEY_DIRECTION\"\n" \
3677
174
            "# key 154 \"KEY_CYCLEWINDOWS\"\n" \
3678
175
            "key 155   ENVELOPE\n" \
3679
176
            "key 156   BOOKMARK\n" \
3680
177
            "# key 157 \"KEY_COMPUTER\"\n" \
3681
178
            "key 158   BACK              WAKE_DROPPED\n" \
3682
179
            "key 159   FORWARD\n" \
3683
180
            "key 160   MEDIA_CLOSE\n" \
3684
181
            "key 161   MEDIA_EJECT\n" \
3685
182
            "key 162   MEDIA_EJECT\n" \
3686
183
            "key 163   MEDIA_NEXT\n" \
3687
184
            "key 164   MEDIA_PLAY_PAUSE\n" \
3688
185
            "key 165   MEDIA_PREVIOUS\n" \
3689
186
            "key 166   MEDIA_STOP\n" \
3690
187
            "key 167   MEDIA_RECORD\n" \
3691
188
            "key 168   MEDIA_REWIND\n" \
3692
189
            "key 169   CALL\n" \
3693
190
            "# key 170 \"KEY_ISO\"\n" \
3694
191
            "key 171   MUSIC\n" \
3695
192
            "key 172   HOME\n" \
3696
193
            "# key 173 \"KEY_REFRESH\"\n" \
3697
194
            "# key 174 \"KEY_EXIT\"\n" \
3698
195
            "# key 175 \"KEY_MOVE\"\n" \
3699
196
            "# key 176 \"KEY_EDIT\"\n" \
3700
197
            "key 177   PAGE_UP\n" \
3701
198
            "key 178   PAGE_DOWN\n" \
3702
199
            "key 179   NUMPAD_LEFT_PAREN\n" \
3703
200
            "key 180   NUMPAD_RIGHT_PAREN\n" \
3704
201
            "# key 181 \"KEY_NEW\"\n" \
3705
202
            "# key 182 \"KEY_REDO\"\n" \
3706
203
            "# key 183   F13\n" \
3707
204
            "# key 184   F14\n" \
3708
205
            "# key 185   F15\n" \
3709
206
            "# key 186   F16\n" \
3710
207
            "# key 187   F17\n" \
3711
208
            "# key 188   F18\n" \
3712
209
            "# key 189   F19\n" \
3713
210
            "# key 190   F20\n" \
3714
211
            "# key 191   F21\n" \
3715
212
            "# key 192   F22\n" \
3716
213
            "# key 193   F23\n" \
3717
214
            "# key 194   F24\n" \
3718
215
            "# key 195 (undefined)\n" \
3719
216
            "# key 196 (undefined)\n" \
3720
217
            "# key 197 (undefined)\n" \
3721
218
            "# key 198 (undefined)\n" \
3722
219
            "# key 199 (undefined)\n" \
3723
220
            "key 200   MEDIA_PLAY\n" \
3724
221
            "key 201   MEDIA_PAUSE\n" \
3725
222
            "# key 202 \"KEY_PROG3\"\n" \
3726
223
            "# key 203 \"KEY_PROG4\"\n" \
3727
224
            "# key 204 (undefined)\n" \
3728
225
            "# key 205 \"KEY_SUSPEND\"\n" \
3729
226
            "# key 206 \"KEY_CLOSE\"\n" \
3730
227
            "key 207   MEDIA_PLAY\n" \
3731
228
            "key 208   MEDIA_FAST_FORWARD\n" \
3732
229
            "# key 209 \"KEY_BASSBOOST\"\n" \
3733
230
            "# key 210 \"KEY_PRINT\"\n" \
3734
231
            "# key 211 \"KEY_HP\"\n" \
3735
232
            "key 212   CAMERA\n" \
3736
233
            "key 213   MUSIC\n" \
3737
234
            "# key 214 \"KEY_QUESTION\"\n" \
3738
235
            "key 215   ENVELOPE\n" \
3739
236
            "# key 216 \"KEY_CHAT\"\n" \
3740
237
            "key 217   SEARCH\n" \
3741
238
            "# key 218 \"KEY_CONNECT\"\n" \
3742
239
            "# key 219 \"KEY_FINANCE\"\n" \
3743
240
            "# key 220 \"KEY_SPORT\"\n" \
3744
241
            "# key 221 \"KEY_SHOP\"\n" \
3745
242
            "# key 222 \"KEY_ALTERASE\"\n" \
3746
243
            "# key 223 \"KEY_CANCEL\"\n" \
3747
244
            "# key 224 \"KEY_BRIGHTNESSDOWN\"\n" \
3748
245
            "# key 225 \"KEY_BRIGHTNESSUP\"\n" \
3749
246
            "key 226   HEADSETHOOK\n" \
3750
247
            "\n" \
3751
248
            "key 256   BUTTON_1\n" \
3752
249
            "key 257   BUTTON_2\n" \
3753
250
            "key 258   BUTTON_3\n" \
3754
251
            "key 259   BUTTON_4\n" \
3755
252
            "key 260   BUTTON_5\n" \
3756
253
            "key 261   BUTTON_6\n" \
3757
254
            "key 262   BUTTON_7\n" \
3758
255
            "key 263   BUTTON_8\n" \
3759
256
            "key 264   BUTTON_9\n" \
3760
257
            "key 265   BUTTON_10\n" \
3761
258
            "key 266   BUTTON_11\n" \
3762
259
            "key 267   BUTTON_12\n" \
3763
260
            "key 268   BUTTON_13\n" \
3764
261
            "key 269   BUTTON_14\n" \
3765
262
            "key 270   BUTTON_15\n" \
3766
263
            "key 271   BUTTON_16\n" \
3767
264
            "\n" \
3768
265
            "key 288   BUTTON_1\n" \
3769
266
            "key 289   BUTTON_2\n" \
3770
267
            "key 290   BUTTON_3\n" \
3771
268
            "key 291   BUTTON_4\n" \
3772
269
            "key 292   BUTTON_5\n" \
3773
270
            "key 293   BUTTON_6\n" \
3774
271
            "key 294   BUTTON_7\n" \
3775
272
            "key 295   BUTTON_8\n" \
3776
273
            "key 296   BUTTON_9\n" \
3777
274
            "key 297   BUTTON_10\n" \
3778
275
            "key 298   BUTTON_11\n" \
3779
276
            "key 299   BUTTON_12\n" \
3780
277
            "key 300   BUTTON_13\n" \
3781
278
            "key 301   BUTTON_14\n" \
3782
279
            "key 302   BUTTON_15\n" \
3783
280
            "key 303   BUTTON_16\n" \
3784
281
            "\n" \
3785
282
            "\n" \
3786
283
            "key 304   BUTTON_A\n" \
3787
284
            "key 305   BUTTON_B\n" \
3788
285
            "key 306   BUTTON_C\n" \
3789
286
            "key 307   BUTTON_X\n" \
3790
287
            "key 308   BUTTON_Y\n" \
3791
288
            "key 309   BUTTON_Z\n" \
3792
289
            "key 310   BUTTON_L1\n" \
3793
290
            "key 311   BUTTON_R1\n" \
3794
291
            "key 312   BUTTON_L2\n" \
3795
292
            "key 313   BUTTON_R2\n" \
3796
293
            "key 314   BUTTON_SELECT\n" \
3797
294
            "key 315   BUTTON_START\n" \
3798
295
            "key 316   BUTTON_MODE\n" \
3799
296
            "key 317   BUTTON_THUMBL\n" \
3800
297
            "key 318   BUTTON_THUMBR\n" \
3801
298
            "\n" \
3802
299
            "\n" \
3803
300
            "# key 352 \"KEY_OK\"\n" \
3804
301
            "key 353   DPAD_CENTER\n" \
3805
302
            "# key 354 \"KEY_GOTO\"\n" \
3806
303
            "# key 355 \"KEY_CLEAR\"\n" \
3807
304
            "# key 356 \"KEY_POWER2\"\n" \
3808
305
            "# key 357 \"KEY_OPTION\"\n" \
3809
306
            "# key 358 \"KEY_INFO\"\n" \
3810
307
            "# key 359 \"KEY_TIME\"\n" \
3811
308
            "# key 360 \"KEY_VENDOR\"\n" \
3812
309
            "# key 361 \"KEY_ARCHIVE\"\n" \
3813
310
            "key 362   GUIDE\n" \
3814
311
            "# key 363 \"KEY_CHANNEL\"\n" \
3815
312
            "# key 364 \"KEY_FAVORITES\"\n" \
3816
313
            "# key 365 \"KEY_EPG\"\n" \
3817
314
            "key 366   DVR\n" \
3818
315
            "# key 367 \"KEY_MHP\"\n" \
3819
316
            "# key 368 \"KEY_LANGUAGE\"\n" \
3820
317
            "# key 369 \"KEY_TITLE\"\n" \
3821
318
            "# key 370 \"KEY_SUBTITLE\"\n" \
3822
319
            "# key 371 \"KEY_ANGLE\"\n" \
3823
320
            "# key 372 \"KEY_ZOOM\"\n" \
3824
321
            "# key 373 \"KEY_MODE\"\n" \
3825
322
            "# key 374 \"KEY_KEYBOARD\"\n" \
3826
323
            "# key 375 \"KEY_SCREEN\"\n" \
3827
324
            "# key 376 \"KEY_PC\"\n" \
3828
325
            "key 377   TV\n" \
3829
326
            "# key 378 \"KEY_TV2\"\n" \
3830
327
            "# key 379 \"KEY_VCR\"\n" \
3831
328
            "# key 380 \"KEY_VCR2\"\n" \
3832
329
            "# key 381 \"KEY_SAT\"\n" \
3833
330
            "# key 382 \"KEY_SAT2\"\n" \
3834
331
            "# key 383 \"KEY_CD\"\n" \
3835
332
            "# key 384 \"KEY_TAPE\"\n" \
3836
333
            "# key 385 \"KEY_RADIO\"\n" \
3837
334
            "# key 386 \"KEY_TUNER\"\n" \
3838
335
            "# key 387 \"KEY_PLAYER\"\n" \
3839
336
            "# key 388 \"KEY_TEXT\"\n" \
3840
337
            "# key 389 \"KEY_DVD\"\n" \
3841
338
            "# key 390 \"KEY_AUX\"\n" \
3842
339
            "# key 391 \"KEY_MP3\"\n" \
3843
340
            "# key 392 \"KEY_AUDIO\"\n" \
3844
341
            "# key 393 \"KEY_VIDEO\"\n" \
3845
342
            "# key 394 \"KEY_DIRECTORY\"\n" \
3846
343
            "# key 395 \"KEY_LIST\"\n" \
3847
344
            "# key 396 \"KEY_MEMO\"\n" \
3848
345
            "key 397   CALENDAR\n" \
3849
346
            "# key 398 \"KEY_RED\"\n" \
3850
347
            "# key 399 \"KEY_GREEN\"\n" \
3851
348
            "# key 400 \"KEY_YELLOW\"\n" \
3852
349
            "# key 401 \"KEY_BLUE\"\n" \
3853
350
            "key 402   CHANNEL_UP\n" \
3854
351
            "key 403   CHANNEL_DOWN\n" \
3855
352
            "# key 404 \"KEY_FIRST\"\n" \
3856
353
            "# key 405 \"KEY_LAST\"\n" \
3857
354
            "# key 406 \"KEY_AB\"\n" \
3858
355
            "# key 407 \"KEY_NEXT\"\n" \
3859
356
            "# key 408 \"KEY_RESTART\"\n" \
3860
357
            "# key 409 \"KEY_SLOW\"\n" \
3861
358
            "# key 410 \"KEY_SHUFFLE\"\n" \
3862
359
            "# key 411 \"KEY_BREAK\"\n" \
3863
360
            "# key 412 \"KEY_PREVIOUS\"\n" \
3864
361
            "# key 413 \"KEY_DIGITS\"\n" \
3865
362
            "# key 414 \"KEY_TEEN\"\n" \
3866
363
            "# key 415 \"KEY_TWEN\"\n" \
3867
364
            "key 429   CONTACTS\n" \
3868
365
            "\n" \
3869
366
            "# key 448 \"KEY_DEL_EOL\"\n" \
3870
367
            "# key 449 \"KEY_DEL_EOS\"\n" \
3871
368
            "# key 450 \"KEY_INS_LINE\"\n" \
3872
369
            "# key 451 \"KEY_DEL_LINE\"\n" \
3873
370
            "\n" \
3874
371
            "\n" \
3875
372
            "key 464   FUNCTION\n" \
3876
373
            "key 465   ESCAPE            FUNCTION\n" \
3877
374
            "key 466   F1                FUNCTION\n" \
3878
375
            "key 467   F2                FUNCTION\n" \
3879
376
            "key 468   F3                FUNCTION\n" \
3880
377
            "key 469   F4                FUNCTION\n" \
3881
378
            "key 470   F5                FUNCTION\n" \
3882
379
            "key 471   F6                FUNCTION\n" \
3883
380
            "key 472   F7                FUNCTION\n" \
3884
381
            "key 473   F8                FUNCTION\n" \
3885
382
            "key 474   F9                FUNCTION\n" \
3886
383
            "key 475   F10               FUNCTION\n" \
3887
384
            "key 476   F11               FUNCTION\n" \
3888
385
            "key 477   F12               FUNCTION\n" \
3889
386
            "key 478   1                 FUNCTION\n" \
3890
387
            "key 479   2                 FUNCTION\n" \
3891
388
            "key 480   D                 FUNCTION\n" \
3892
389
            "key 481   E                 FUNCTION\n" \
3893
390
            "key 482   F                 FUNCTION\n" \
3894
391
            "key 483   S                 FUNCTION\n" \
3895
392
            "key 484   B                 FUNCTION\n" \
3896
393
            "\n" \
3897
394
            "\n" \
3898
395
            "# key 497 KEY_BRL_DOT1\n" \
3899
396
            "# key 498 KEY_BRL_DOT2\n" \
3900
397
            "# key 499 KEY_BRL_DOT3\n" \
3901
398
            "# key 500 KEY_BRL_DOT4\n" \
3902
399
            "# key 501 KEY_BRL_DOT5\n" \
3903
400
            "# key 502 KEY_BRL_DOT6\n" \
3904
401
            "# key 503 KEY_BRL_DOT7\n" \
3905
402
            "# key 504 KEY_BRL_DOT8\n" \
3906
403
            "\n" \
3907
404
            "\n" \
3908
405
            "# Joystick and game controller axes.\n" \
3909
406
            "# Axes that are not mapped will be assigned generic axis numbers by the input subsystem.\n" \
3910
407
            "axis 0x00 X\n" \
3911
408
            "axis 0x01 Y\n" \
3912
409
            "axis 0x02 Z\n" \
3913
410
            "axis 0x03 RX\n" \
3914
411
            "axis 0x04 RY\n" \
3915
412
            "axis 0x05 RZ\n" \
3916
413
            "axis 0x06 THROTTLE\n" \
3917
414
            "axis 0x07 RUDDER\n" \
3918
415
            "axis 0x08 WHEEL\n" \
3919
416
            "axis 0x09 GAS\n" \
3920
417
            "axis 0x0a BRAKE\n" \
3921
418
            "axis 0x10 HAT_X\n" \
3922
419
            "axis 0x11 HAT_Y\n";
3923
420
    return result;
3924
421
}
3925
422
3926
423
const char* android::GenericKeyMap::keymap_contents()
3927
424
{
3928
425
    static const char* result = 
3929
426
            "type FULL\n"                       \
3930
427
            "\n" \
3931
428
            "### Basic QWERTY keys ###\n" \
3932
429
            "\n" \
3933
430
            "key A {\n" \
3934
431
            "    label:                              'A'\n" \
3935
432
            "    base:                               'a'\n" \
3936
433
            "    shift, capslock:                    'A'\n" \
3937
434
            "}\n" \
3938
435
            "\n" \
3939
436
            "key B {\n" \
3940
437
            "    label:                              'B'\n" \
3941
438
            "    base:                               'b'\n" \
3942
439
            "    shift, capslock:                    'B'\n" \
3943
440
            "}\n" \
3944
441
            "\n" \
3945
442
            "key C {\n" \
3946
443
            "    label:                              'C'\n" \
3947
444
            "    base:                               'c'\n" \
3948
445
            "    shift, capslock:                    'C'\n" \
3949
446
            "    alt:                                '\\u00e7'\n" \
3950
447
            "    shift+alt:                          '\\u00c7'\n" \
3951
448
            "}\n" \
3952
449
            "\n" \
3953
450
            "key D {\n" \
3954
451
            "    label:                              'D'\n" \
3955
452
            "    base:                               'd'\n" \
3956
453
            "    shift, capslock:                    'D'\n" \
3957
454
            "}\n" \
3958
455
            "\n" \
3959
456
            "key E {\n" \
3960
457
            "    label:                              'E'\n" \
3961
458
            "    base:                               'e'\n" \
3962
459
            "    shift, capslock:                    'E'\n" \
3963
460
            "    alt:                                '\\u0301'\n" \
3964
461
            "}\n" \
3965
462
            "\n" \
3966
463
            "key F {\n" \
3967
464
            "    label:                              'F'\n" \
3968
465
            "    base:                               'f'\n" \
3969
466
            "    shift, capslock:                    'F'\n" \
3970
467
            "}\n" \
3971
468
            "\n" \
3972
469
            "key G {\n" \
3973
470
            "    label:                              'G'\n" \
3974
471
            "    base:                               'g'\n" \
3975
472
            "    shift, capslock:                    'G'\n" \
3976
473
            "}\n" \
3977
474
            "\n" \
3978
475
            "key H {\n" \
3979
476
            "    label:                              'H'\n" \
3980
477
            "    base:                               'h'\n" \
3981
478
            "    shift, capslock:                    'H'\n" \
3982
479
            "}\n" \
3983
480
            "\n" \
3984
481
            "key I {\n" \
3985
482
            "    label:                              'I'\n" \
3986
483
            "    base:                               'i'\n" \
3987
484
            "    shift, capslock:                    'I'\n" \
3988
485
            "    alt:                                '\\u0302'\n" \
3989
486
            "}\n" \
3990
487
            "\n" \
3991
488
            "key J {\n" \
3992
489
            "    label:                              'J'\n" \
3993
490
            "    base:                               'j'\n" \
3994
491
            "    shift, capslock:                    'J'\n" \
3995
492
            "}\n" \
3996
493
            "\n" \
3997
494
            "key K {\n" \
3998
495
            "    label:                              'K'\n" \
3999
496
            "    base:                               'k'\n" \
4000
497
            "    shift, capslock:                    'K'\n" \
4001
498
            "}\n" \
4002
499
            "\n" \
4003
500
            "key L {\n" \
4004
501
            "    label:                              'L'\n" \
4005
502
            "    base:                               'l'\n" \
4006
503
            "    shift, capslock:                    'L'\n" \
4007
504
            "}\n" \
4008
505
            "\n" \
4009
506
            "key M {\n" \
4010
507
            "    label:                              'M'\n" \
4011
508
            "    base:                               'm'\n" \
4012
509
            "    shift, capslock:                    'M'\n" \
4013
510
            "}\n" \
4014
511
            "\n" \
4015
512
            "key N {\n" \
4016
513
            "    label:                              'N'\n" \
4017
514
            "    base:                               'n'\n" \
4018
515
            "    shift, capslock:                    'N'\n" \
4019
516
            "    alt:                                '\\u0303'\n" \
4020
517
            "}\n" \
4021
518
            "\n" \
4022
519
            "key O {\n" \
4023
520
            "    label:                              'O'\n" \
4024
521
            "    base:                               'o'\n" \
4025
522
            "    shift, capslock:                    'O'\n" \
4026
523
            "}\n" \
4027
524
            "\n" \
4028
525
            "key P {\n" \
4029
526
            "    label:                              'P'\n" \
4030
527
            "    base:                               'p'\n" \
4031
528
            "    shift, capslock:                    'P'\n" \
4032
529
            "}\n" \
4033
530
            "\n" \
4034
531
            "key Q {\n" \
4035
532
            "    label:                              'Q'\n" \
4036
533
            "    base:                               'q'\n" \
4037
534
            "    shift, capslock:                    'Q'\n" \
4038
535
            "}\n" \
4039
536
            "\n" \
4040
537
            "key R {\n" \
4041
538
            "    label:                              'R'\n" \
4042
539
            "    base:                               'r'\n" \
4043
540
            "    shift, capslock:                    'R'\n" \
4044
541
            "}\n" \
4045
542
            "\n" \
4046
543
            "key S {\n" \
4047
544
            "    label:                              'S'\n" \
4048
545
            "    base:                               's'\n" \
4049
546
            "    shift, capslock:                    'S'\n" \
4050
547
            "    alt:                                '\\u00df'\n" \
4051
548
            "}\n" \
4052
549
            "\n" \
4053
550
            "key T {\n" \
4054
551
            "    label:                              'T'\n" \
4055
552
            "    base:                               't'\n" \
4056
553
            "    shift, capslock:                    'T'\n" \
4057
554
            "}\n" \
4058
555
            "\n" \
4059
556
            "key U {\n" \
4060
557
            "    label:                              'U'\n" \
4061
558
            "    base:                               'u'\n" \
4062
559
            "    shift, capslock:                    'U'\n" \
4063
560
            "    alt:                                '\\u0308'\n" \
4064
561
            "}\n" \
4065
562
            "\n" \
4066
563
            "key V {\n" \
4067
564
            "    label:                              'V'\n" \
4068
565
            "    base:                               'v'\n" \
4069
566
            "    shift, capslock:                    'V'\n" \
4070
567
            "}\n" \
4071
568
            "\n" \
4072
569
            "key W {\n" \
4073
570
            "    label:                              'W'\n" \
4074
571
            "    base:                               'w'\n" \
4075
572
            "    shift, capslock:                    'W'\n" \
4076
573
            "}\n" \
4077
574
            "\n" \
4078
575
            "key X {\n" \
4079
576
            "    label:                              'X'\n" \
4080
577
            "    base:                               'x'\n" \
4081
578
            "    shift, capslock:                    'X'\n" \
4082
579
            "}\n" \
4083
580
            "\n" \
4084
581
            "key Y {\n" \
4085
582
            "    label:                              'Y'\n" \
4086
583
            "    base:                               'y'\n" \
4087
584
            "    shift, capslock:                    'Y'\n" \
4088
585
            "}\n" \
4089
586
            "\n" \
4090
587
            "key Z {\n" \
4091
588
            "    label:                              'Z'\n" \
4092
589
            "    base:                               'z'\n" \
4093
590
            "    shift, capslock:                    'Z'\n" \
4094
591
            "}\n" \
4095
592
            "\n" \
4096
593
            "key 0 {\n" \
4097
594
            "    label:                              '0'\n" \
4098
595
            "    base:                               '0'\n" \
4099
596
            "    shift:                              ')'\n" \
4100
597
            "}\n" \
4101
598
            "\n" \
4102
599
            "key 1 {\n" \
4103
600
            "    label:                              '1'\n" \
4104
601
            "    base:                               '1'\n" \
4105
602
            "    shift:                              '!'\n" \
4106
603
            "}\n" \
4107
604
            "\n" \
4108
605
            "key 2 {\n" \
4109
606
            "    label:                              '2'\n" \
4110
607
            "    base:                               '2'\n" \
4111
608
            "    shift:                              '@'\n" \
4112
609
            "}\n" \
4113
610
            "\n" \
4114
611
            "key 3 {\n" \
4115
612
            "    label:                              '3'\n" \
4116
613
            "    base:                               '3'\n" \
4117
614
            "    shift:                              '#'\n" \
4118
615
            "}\n" \
4119
616
            "\n" \
4120
617
            "key 4 {\n" \
4121
618
            "    label:                              '4'\n" \
4122
619
            "    base:                               '4'\n" \
4123
620
            "    shift:                              '$'\n" \
4124
621
            "}\n" \
4125
622
            "\n" \
4126
623
            "key 5 {\n" \
4127
624
            "    label:                              '5'\n" \
4128
625
            "    base:                               '5'\n" \
4129
626
            "    shift:                              '%'\n" \
4130
627
            "}\n" \
4131
628
            "\n" \
4132
629
            "key 6 {\n" \
4133
630
            "    label:                              '6'\n" \
4134
631
            "    base:                               '6'\n" \
4135
632
            "    shift:                              '^'\n" \
4136
633
            "    alt+shift:                          '\\u0302'\n" \
4137
634
            "}\n" \
4138
635
            "\n" \
4139
636
            "key 7 {\n" \
4140
637
            "    label:                              '7'\n" \
4141
638
            "    base:                               '7'\n" \
4142
639
            "    shift:                              '&'\n" \
4143
640
            "}\n" \
4144
641
            "\n" \
4145
642
            "key 8 {\n" \
4146
643
            "    label:                              '8'\n" \
4147
644
            "    base:                               '8'\n" \
4148
645
            "    shift:                              '*'\n" \
4149
646
            "}\n" \
4150
647
            "\n" \
4151
648
            "key 9 {\n" \
4152
649
            "    label:                              '9'\n" \
4153
650
            "    base:                               '9'\n" \
4154
651
            "    shift:                              '('\n" \
4155
652
            "}\n" \
4156
653
            "\n" \
4157
654
            "key SPACE {\n" \
4158
655
            "    label:                              ' '\n" \
4159
656
            "    base:                               ' '\n" \
4160
657
            "    alt, meta:                          fallback SEARCH\n" \
4161
658
            "    ctrl:                               fallback LANGUAGE_SWITCH\n" \
4162
659
            "}\n" \
4163
660
            "\n" \
4164
661
            "key ENTER {\n" \
4165
662
            "    label:                              '\\n'\n" \
4166
663
            "    base:                               '\\n'\n" \
4167
664
            "}\n" \
4168
665
            "\n" \
4169
666
            "key TAB {\n" \
4170
667
            "    label:                              '\\t'\n" \
4171
668
            "    base:                               '\\t'\n" \
4172
669
            "}\n" \
4173
670
            "\n" \
4174
671
            "key COMMA {\n" \
4175
672
            "    label:                              ','\n" \
4176
673
            "    base:                               ','\n" \
4177
674
            "    shift:                              '<'\n" \
4178
675
            "}\n" \
4179
676
            "\n" \
4180
677
            "key PERIOD {\n" \
4181
678
            "    label:                              '.'\n" \
4182
679
            "    base:                               '.'\n" \
4183
680
            "    shift:                              '>'\n" \
4184
681
            "}\n" \
4185
682
            "\n" \
4186
683
            "key SLASH {\n" \
4187
684
            "    label:                              '/'\n" \
4188
685
            "    base:                               '/'\n" \
4189
686
            "    shift:                              '?'\n" \
4190
687
            "}\n" \
4191
688
            "\n" \
4192
689
            "key GRAVE {\n" \
4193
690
            "    label:                              '`'\n" \
4194
691
            "    base:                               '`'\n" \
4195
692
            "    shift:                              '~'\n" \
4196
693
            "    alt:                                '\\u0300'\n" \
4197
694
            "    alt+shift:                          '\\u0303'\n" \
4198
695
            "}\n" \
4199
696
            "\n" \
4200
697
            "key MINUS {\n" \
4201
698
            "    label:                              '-'\n" \
4202
699
            "    base:                               '-'\n" \
4203
700
            "    shift:                              '_'\n" \
4204
701
            "}\n" \
4205
702
            "\n" \
4206
703
            "key EQUALS {\n" \
4207
704
            "    label:                              '='\n" \
4208
705
            "    base:                               '='\n" \
4209
706
            "    shift:                              '+'\n" \
4210
707
            "}\n" \
4211
708
            "\n" \
4212
709
            "key LEFT_BRACKET {\n" \
4213
710
            "    label:                              '['\n" \
4214
711
            "    base:                               '['\n" \
4215
712
            "    shift:                              '{'\n" \
4216
713
            "}\n" \
4217
714
            "\n" \
4218
715
            "key RIGHT_BRACKET {\n" \
4219
716
            "    label:                              ']'\n" \
4220
717
            "    base:                               ']'\n" \
4221
718
            "    shift:                              '}'\n" \
4222
719
            "}\n" \
4223
720
            "\n" \
4224
721
            "key BACKSLASH {\n" \
4225
722
            "    label:                              '\\\\'\n" \
4226
723
            "    base:                               '\\\\'\n" \
4227
724
            "    shift:                              '|'\n" \
4228
725
            "}\n" \
4229
726
            "\n" \
4230
727
            "key SEMICOLON {\n" \
4231
728
            "    label:                              ';'\n" \
4232
729
            "    base:                               ';'\n" \
4233
730
            "    shift:                              ':'\n" \
4234
731
            "}\n" \
4235
732
            "\n" \
4236
733
            "key APOSTROPHE {\n" \
4237
734
            "    label:                              '\\''\n" \
4238
735
            "    base:                               '\\''\n" \
4239
736
            "    shift:                              '\"'\n" \
4240
737
            "}\n" \
4241
738
            "\n" \
4242
739
            "### Numeric keypad ###\n" \
4243
740
            "\n" \
4244
741
            "key NUMPAD_0 {\n" \
4245
742
            "    label:                              '0'\n" \
4246
743
            "    base:                               fallback INSERT\n" \
4247
744
            "    numlock:                            '0'\n" \
4248
745
            "}\n" \
4249
746
            "\n" \
4250
747
            "key NUMPAD_1 {\n" \
4251
748
            "    label:                              '1'\n" \
4252
749
            "    base:                               fallback MOVE_END\n" \
4253
750
            "    numlock:                            '1'\n" \
4254
751
            "}\n" \
4255
752
            "\n" \
4256
753
            "key NUMPAD_2 {\n" \
4257
754
            "    label:                              '2'\n" \
4258
755
            "    base:                               fallback DPAD_DOWN\n" \
4259
756
            "    numlock:                            '2'\n" \
4260
757
            "}\n" \
4261
758
            "\n" \
4262
759
            "key NUMPAD_3 {\n" \
4263
760
            "    label:                              '3'\n" \
4264
761
            "    base:                               fallback PAGE_DOWN\n" \
4265
762
            "    numlock:                            '3'\n" \
4266
763
            "}\n" \
4267
764
            "\n" \
4268
765
            "key NUMPAD_4 {\n" \
4269
766
            "    label:                              '4'\n" \
4270
767
            "    base:                               fallback DPAD_LEFT\n" \
4271
768
            "    numlock:                            '4'\n" \
4272
769
            "}\n" \
4273
770
            "\n" \
4274
771
            "key NUMPAD_5 {\n" \
4275
772
            "    label:                              '5'\n" \
4276
773
            "    base:                               fallback DPAD_CENTER\n" \
4277
774
            "    numlock:                            '5'\n" \
4278
775
            "}\n" \
4279
776
            "\n" \
4280
777
            "key NUMPAD_6 {\n" \
4281
778
            "    label:                              '6'\n" \
4282
779
            "    base:                               fallback DPAD_RIGHT\n" \
4283
780
            "    numlock:                            '6'\n" \
4284
781
            "}\n" \
4285
782
            "\n" \
4286
783
            "key NUMPAD_7 {\n" \
4287
784
            "    label:                              '7'\n" \
4288
785
            "    base:                               fallback MOVE_HOME\n" \
4289
786
            "    numlock:                            '7'\n" \
4290
787
            "}\n" \
4291
788
            "\n" \
4292
789
            "key NUMPAD_8 {\n" \
4293
790
            "    label:                              '8'\n" \
4294
791
            "    base:                               fallback DPAD_UP\n" \
4295
792
            "    numlock:                            '8'\n" \
4296
793
            "}\n" \
4297
794
            "\n" \
4298
795
            "key NUMPAD_9 {\n" \
4299
796
            "    label:                              '9'\n" \
4300
797
            "    base:                               fallback PAGE_UP\n" \
4301
798
            "    numlock:                            '9'\n" \
4302
799
            "}\n" \
4303
800
            "\n" \
4304
801
            "key NUMPAD_LEFT_PAREN {\n" \
4305
802
            "    label:                              '('\n" \
4306
803
            "    base:                               '('\n" \
4307
804
            "}\n" \
4308
805
            "\n" \
4309
806
            "key NUMPAD_RIGHT_PAREN {\n" \
4310
807
            "    label:                              ')'\n" \
4311
808
            "    base:                               ')'\n" \
4312
809
            "}\n" \
4313
810
            "\n" \
4314
811
            "key NUMPAD_DIVIDE {\n" \
4315
812
            "    label:                              '/'\n" \
4316
813
            "    base:                               '/'\n" \
4317
814
            "}\n" \
4318
815
            "\n" \
4319
816
            "key NUMPAD_MULTIPLY {\n" \
4320
817
            "    label:                              '*'\n" \
4321
818
            "    base:                               '*'\n" \
4322
819
            "}\n" \
4323
820
            "\n" \
4324
821
            "key NUMPAD_SUBTRACT {\n" \
4325
822
            "    label:                              '-'\n" \
4326
823
            "    base:                               '-'\n" \
4327
824
            "}\n" \
4328
825
            "\n" \
4329
826
            "key NUMPAD_ADD {\n" \
4330
827
            "    label:                              '+'\n" \
4331
828
            "    base:                               '+'\n" \
4332
829
            "}\n" \
4333
830
            "\n" \
4334
831
            "key NUMPAD_DOT {\n" \
4335
832
            "    label:                              '.'\n" \
4336
833
            "    base:                               fallback FORWARD_DEL\n" \
4337
834
            "    numlock:                            '.'\n" \
4338
835
            "}\n" \
4339
836
            "\n" \
4340
837
            "key NUMPAD_COMMA {\n" \
4341
838
            "    label:                              ','\n" \
4342
839
            "    base:                               ','\n" \
4343
840
            "}\n" \
4344
841
            "\n" \
4345
842
            "key NUMPAD_EQUALS {\n" \
4346
843
            "    label:                              '='\n" \
4347
844
            "    base:                               '='\n" \
4348
845
            "}\n" \
4349
846
            "\n" \
4350
847
            "key NUMPAD_ENTER {\n" \
4351
848
            "    label:                              '\\n'\n" \
4352
849
            "    base:                               '\\n' fallback ENTER\n" \
4353
850
            "    ctrl, alt, meta:                    none fallback ENTER\n" \
4354
851
            "}\n" \
4355
852
            "\n" \
4356
853
            "### Special keys on phones ###\n" \
4357
854
            "\n" \
4358
855
            "key AT {\n" \
4359
856
            "    label:                              '@'\n" \
4360
857
            "    base:                               '@'\n" \
4361
858
            "}\n" \
4362
859
            "\n" \
4363
860
            "key STAR {\n" \
4364
861
            "    label:                              '*'\n" \
4365
862
            "    base:                               '*'\n" \
4366
863
            "}\n" \
4367
864
            "\n" \
4368
865
            "key POUND {\n" \
4369
866
            "    label:                              '#'\n" \
4370
867
            "    base:                               '#'\n" \
4371
868
            "}\n" \
4372
869
            "\n" \
4373
870
            "key PLUS {\n" \
4374
871
            "    label:                              '+'\n" \
4375
872
            "    base:                               '+'\n" \
4376
873
            "}\n" \
4377
874
            "\n" \
4378
875
            "### Non-printing keys ###\n" \
4379
876
            "\n" \
4380
877
            "key ESCAPE {\n" \
4381
878
            "    base:                               fallback BACK\n" \
4382
879
            "    alt, meta:                          fallback HOME\n" \
4383
880
            "    ctrl:                               fallback MENU\n" \
4384
881
            "}\n" \
4385
882
            "\n" \
4386
883
            "### Gamepad buttons ###\n" \
4387
884
            "\n" \
4388
885
            "key BUTTON_A {\n" \
4389
886
            "    base:                               fallback BACK\n" \
4390
887
            "}\n" \
4391
888
            "\n" \
4392
889
            "key BUTTON_B {\n" \
4393
890
            "    base:                               fallback BACK\n" \
4394
891
            "}\n" \
4395
892
            "\n" \
4396
893
            "key BUTTON_C {\n" \
4397
894
            "    base:                               fallback BACK\n" \
4398
895
            "}\n" \
4399
896
            "\n" \
4400
897
            "key BUTTON_X {\n" \
4401
898
            "    base:                               fallback DPAD_CENTER\n" \
4402
899
            "}\n" \
4403
900
            "\n" \
4404
901
            "key BUTTON_Y {\n" \
4405
902
            "    base:                               fallback DPAD_CENTER\n" \
4406
903
            "}\n" \
4407
904
            "\n" \
4408
905
            "key BUTTON_Z {\n" \
4409
906
            "    base:                               fallback DPAD_CENTER\n" \
4410
907
            "}\n" \
4411
908
            "\n" \
4412
909
            "key BUTTON_L1 {\n" \
4413
910
            "    base:                               none\n" \
4414
911
            "}\n" \
4415
912
            "\n" \
4416
913
            "key BUTTON_R1 {\n" \
4417
914
            "    base:                               none\n" \
4418
915
            "}\n" \
4419
916
            "\n" \
4420
917
            "key BUTTON_L2 {\n" \
4421
918
            "    base:                               none\n" \
4422
919
            "}\n" \
4423
920
            "\n" \
4424
921
            "key BUTTON_R2 {\n" \
4425
922
            "    base:                               none\n" \
4426
923
            "}\n" \
4427
924
            "\n" \
4428
925
            "key BUTTON_THUMBL {\n" \
4429
926
            "    base:                               fallback DPAD_CENTER\n" \
4430
927
            "}\n" \
4431
928
            "\n" \
4432
929
            "key BUTTON_THUMBR {\n" \
4433
930
            "    base:                               fallback DPAD_CENTER\n" \
4434
931
            "}\n" \
4435
932
            "\n" \
4436
933
            "key BUTTON_START {\n" \
4437
934
            "    base:                               fallback HOME\n" \
4438
935
            "}\n" \
4439
936
            "\n" \
4440
937
            "key BUTTON_SELECT {\n" \
4441
938
            "    base:                               fallback MENU\n" \
4442
939
            "}\n" \
4443
940
            "\n" \
4444
941
            "key BUTTON_MODE {\n" \
4445
942
            "    base:                               fallback MENU\n" \
4446
943
            "}\n" \
4447
944
            "\n" \
4448
945
            "key BUTTON_1 {\n" \
4449
946
            "    base:                               fallback DPAD_CENTER\n" \
4450
947
            "}\n" \
4451
948
            "\n" \
4452
949
            "key BUTTON_2 {\n" \
4453
950
            "    base:                               fallback DPAD_CENTER\n" \
4454
951
            "}\n" \
4455
952
            "\n" \
4456
953
            "key BUTTON_3 {\n" \
4457
954
            "    base:                               fallback DPAD_CENTER\n" \
4458
955
            "}\n" \
4459
956
            "\n" \
4460
957
            "key BUTTON_4 {\n" \
4461
958
            "    base:                               fallback DPAD_CENTER\n" \
4462
959
            "}\n" \
4463
960
            "\n" \
4464
961
            "key BUTTON_5 {\n" \
4465
962
            "    base:                               fallback DPAD_CENTER\n" \
4466
963
            "}\n" \
4467
964
            "\n" \
4468
965
            "key BUTTON_6 {\n" \
4469
966
            "    base:                               fallback DPAD_CENTER\n" \
4470
967
            "}\n" \
4471
968
            "\n" \
4472
969
            "key BUTTON_7 {\n" \
4473
970
            "    base:                               fallback DPAD_CENTER\n" \
4474
971
            "}\n" \
4475
972
            "\n" \
4476
973
            "key BUTTON_8 {\n" \
4477
974
            "    base:                               fallback DPAD_CENTER\n" \
4478
975
            "}\n" \
4479
976
            "\n" \
4480
977
            "key BUTTON_9 {\n" \
4481
978
            "    base:                               fallback DPAD_CENTER\n" \
4482
979
            "}\n" \
4483
980
            "\n" \
4484
981
            "key BUTTON_10 {\n" \
4485
982
            "    base:                               fallback DPAD_CENTER\n" \
4486
983
            "}\n" \
4487
984
            "\n" \
4488
985
            "key BUTTON_11 {\n" \
4489
986
            "    base:                               fallback DPAD_CENTER\n" \
4490
987
            "}\n" \
4491
988
            "\n" \
4492
989
            "key BUTTON_12 {\n" \
4493
990
            "    base:                               fallback DPAD_CENTER\n" \
4494
991
            "}\n" \
4495
992
            "\n" \
4496
993
            "key BUTTON_13 {\n" \
4497
994
            "    base:                               fallback DPAD_CENTER\n" \
4498
995
            "}\n" \
4499
996
            "\n" \
4500
997
            "key BUTTON_14 {\n" \
4501
998
            "    base:                               fallback DPAD_CENTER\n" \
4502
999
            "}\n" \
4503
1000
            "\n" \
4504
1001
            "key BUTTON_15 {\n" \
4505
1002
            "    base:                               fallback DPAD_CENTER\n" \
4506
1003
            "}\n" \
4507
1004
            "\n" \
4508
1005
            "key BUTTON_16 {\n" \
4509
1006
            "    base:                               fallback DPAD_CENTER\n" \
4510
1007
            "}";
4511
1008
    return result;
4512
1009
}
4513
1010
0
4514
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp'
4515
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp	2015-06-15 22:24:08 +0000
4516
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDevice.cpp	1970-01-01 00:00:00 +0000
4517
@@ -1,205 +0,0 @@
4518
1
/*
4519
2
 * Copyright (C) 2012 The Android Open Source Project
4520
3
 *
4521
4
 * Licensed under the Apache License, Version 2.0 (the "License");
4522
5
 * you may not use this file except in compliance with the License.
4523
6
 * You may obtain a copy of the License at
4524
7
 *
4525
8
 *      http://www.apache.org/licenses/LICENSE-2.0
4526
9
 *
4527
10
 * Unless required by applicable law or agreed to in writing, software
4528
11
 * distributed under the License is distributed on an "AS IS" BASIS,
4529
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4530
13
 * See the License for the specific language governing permissions and
4531
14
 * limitations under the License.
4532
15
 */
4533
16
4534
17
#define LOG_TAG "InputDevice"
4535
18
4536
19
#include <cutils/log.h>
4537
20
#define DEBUG_PROBE 0
4538
21
4539
22
#include <stdlib.h>
4540
23
#include <unistd.h>
4541
24
#include <ctype.h>
4542
25
4543
26
#include <androidfw/InputDevice.h>
4544
27
4545
28
namespace android {
4546
29
4547
30
static const char* CONFIGURATION_FILE_DIR[] = {
4548
31
        "idc/",
4549
32
        "keylayout/",
4550
33
        "keychars/",
4551
34
};
4552
35
4553
36
static const char* CONFIGURATION_FILE_EXTENSION[] = {
4554
37
        ".idc",
4555
38
        ".kl",
4556
39
        ".kcm",
4557
40
};
4558
41
4559
42
static bool isValidNameChar(char ch) {
4560
43
    return isascii(ch) && (isdigit(ch) || isalpha(ch) || ch == '-' || ch == '_');
4561
44
}
4562
45
4563
46
static void appendInputDeviceConfigurationFileRelativePath(String8& path,
4564
47
        const String8& name, InputDeviceConfigurationFileType type) {
4565
48
    path.append(CONFIGURATION_FILE_DIR[type]);
4566
49
    for (size_t i = 0; i < name.length(); i++) {
4567
50
        char ch = name[i];
4568
51
        if (!isValidNameChar(ch)) {
4569
52
            ch = '_';
4570
53
        }
4571
54
        path.append(&ch, 1);
4572
55
    }
4573
56
    path.append(CONFIGURATION_FILE_EXTENSION[type]);
4574
57
}
4575
58
4576
59
String8 getInputDeviceConfigurationFilePathByDeviceIdentifier(
4577
60
        const InputDeviceIdentifier& deviceIdentifier,
4578
61
        InputDeviceConfigurationFileType type) {
4579
62
    if (deviceIdentifier.vendor !=0 && deviceIdentifier.product != 0) {
4580
63
        if (deviceIdentifier.version != 0) {
4581
64
            // Try vendor product version.
4582
65
            String8 versionPath(getInputDeviceConfigurationFilePathByName(
4583
66
                    formatString8("Vendor_%04x_Product_%04x_Version_%04x",
4584
67
                            deviceIdentifier.vendor, deviceIdentifier.product,
4585
68
                            deviceIdentifier.version),
4586
69
                    type));
4587
70
            if (!isEmpty(versionPath)) {
4588
71
                return versionPath;
4589
72
            }
4590
73
        }
4591
74
4592
75
        // Try vendor product.
4593
76
        String8 productPath(getInputDeviceConfigurationFilePathByName(
4594
77
                formatString8("Vendor_%04x_Product_%04x",
4595
78
                        deviceIdentifier.vendor, deviceIdentifier.product),
4596
79
                type));
4597
80
        if (!isEmpty(productPath)) {
4598
81
            return productPath;
4599
82
        }
4600
83
    }
4601
84
4602
85
    // Try device name.
4603
86
    return getInputDeviceConfigurationFilePathByName(deviceIdentifier.name, type);
4604
87
}
4605
88
4606
89
String8 getConfigurationFilePathInDirectory(String8 const& directory, String8 const& name, InputDeviceConfigurationFileType type)
4607
90
{
4608
91
    String8 path = directory;
4609
92
    appendInputDeviceConfigurationFileRelativePath(path, name, type);
4610
93
#if DEBUG_PROBE
4611
94
    ALOGD("Probing for input device configuration file: path='%s'", path.c_str());
4612
95
#endif
4613
96
    if (!access(c_str(path), R_OK)) {
4614
97
#if DEBUG_PROBE
4615
98
        ALOGD("Found");
4616
99
#endif
4617
100
        return path;
4618
101
    }
4619
102
4620
103
    return String8();
4621
104
}
4622
105
    
4623
106
String8 getInputDeviceConfigurationFilePathByName(
4624
107
        const String8& name, InputDeviceConfigurationFileType type) {
4625
108
    // Search system repository.
4626
109
    String8 path;
4627
110
    setTo(path, "/usr/share/");
4628
111
    auto result = getConfigurationFilePathInDirectory(path, name, type);
4629
112
    if (result.length())
4630
113
        return result;
4631
114
4632
115
    {
4633
116
        const char *root_env = getenv("ANDROID_ROOT");
4634
117
        if (root_env == NULL) root_env = "";
4635
118
        setTo(path, root_env);
4636
119
    }
4637
120
    // </mir modifications>
4638
121
    path.append("/usr/");
4639
122
    result = getConfigurationFilePathInDirectory(path, name, type);
4640
123
    if (result.length())
4641
124
        return result;
4642
125
4643
126
    // Search user repository.
4644
127
    // TODO Should only look here if not in safe mode. ( ?? ~ racarr)
4645
128
    {
4646
129
        const char *data_env = getenv("ANDROID_DATA");
4647
130
        if (data_env == NULL) data_env = "";
4648
131
        setTo(path, data_env);
4649
132
    }
4650
133
4651
134
    path.append("/system/devices/");
4652
135
    result = getConfigurationFilePathInDirectory(path, name, type);
4653
136
    if (result.length())
4654
137
        return result;
4655
138
4656
139
    // Not found.
4657
140
#if DEBUG_PROBE
4658
141
    ALOGD("Probe failed to find input device configuration file: name='%s', type=%d",
4659
142
            name.c_str(), type);
4660
143
#endif
4661
144
    return String8();
4662
145
}
4663
146
4664
147
4665
148
// --- InputDeviceInfo ---
4666
149
4667
150
InputDeviceInfo::InputDeviceInfo() {
4668
151
    initialize(-1, -1, InputDeviceIdentifier(), String8(), false);
4669
152
}
4670
153
4671
154
InputDeviceInfo::InputDeviceInfo(const InputDeviceInfo& other) :
4672
155
        mId(other.mId), mGeneration(other.mGeneration), mIdentifier(other.mIdentifier),
4673
156
        mAlias(other.mAlias), mIsExternal(other.mIsExternal), mSources(other.mSources),
4674
157
        mKeyboardType(other.mKeyboardType),
4675
158
        mKeyCharacterMap(other.mKeyCharacterMap),
4676
159
        mHasVibrator(other.mHasVibrator),
4677
160
        mMotionRanges(other.mMotionRanges) {
4678
161
}
4679
162
4680
163
InputDeviceInfo::~InputDeviceInfo() {
4681
164
}
4682
165
4683
166
void InputDeviceInfo::initialize(int32_t id, int32_t generation,
4684
167
        const InputDeviceIdentifier& identifier, const String8& alias, bool isExternal) {
4685
168
    mId = id;
4686
169
    mGeneration = generation;
4687
170
    mIdentifier = identifier;
4688
171
    mAlias = alias;
4689
172
    mIsExternal = isExternal;
4690
173
    mSources = 0;
4691
174
    mKeyboardType = AINPUT_KEYBOARD_TYPE_NONE;
4692
175
    mHasVibrator = false;
4693
176
    mMotionRanges.clear();
4694
177
}
4695
178
4696
179
const InputDeviceInfo::MotionRange* InputDeviceInfo::getMotionRange(
4697
180
        int32_t axis, uint32_t source) const {
4698
181
    size_t numRanges = mMotionRanges.size();
4699
182
    for (size_t i = 0; i < numRanges; i++) {
4700
183
        const MotionRange& range = mMotionRanges.itemAt(i);
4701
184
        if (range.axis == axis && range.source == source) {
4702
185
            return &range;
4703
186
        }
4704
187
    }
4705
188
    return NULL;
4706
189
}
4707
190
4708
191
void InputDeviceInfo::addSource(uint32_t source) {
4709
192
    mSources |= source;
4710
193
}
4711
194
4712
195
void InputDeviceInfo::addMotionRange(int32_t axis, uint32_t source, float min, float max,
4713
196
        float flat, float fuzz) {
4714
197
    MotionRange range = { axis, source, min, max, flat, fuzz };
4715
198
    mMotionRanges.add(range);
4716
199
}
4717
200
4718
201
void InputDeviceInfo::addMotionRange(const MotionRange& range) {
4719
202
    mMotionRanges.add(range);
4720
203
}
4721
204
4722
205
} // namespace android
4723
206
0
4724
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp'
4725
--- 3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp	2015-08-17 18:33:38 +0000
4726
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputListener.cpp	1970-01-01 00:00:00 +0000
4727
@@ -1,183 +0,0 @@
4728
1
/*
4729
2
 * Copyright (C) 2011 The Android Open Source Project
4730
3
 *
4731
4
 * Licensed under the Apache License, Version 2.0 (the "License");
4732
5
 * you may not use this file except in compliance with the License.
4733
6
 * You may obtain a copy of the License at
4734
7
 *
4735
8
 *      http://www.apache.org/licenses/LICENSE-2.0
4736
9
 *
4737
10
 * Unless required by applicable law or agreed to in writing, software
4738
11
 * distributed under the License is distributed on an "AS IS" BASIS,
4739
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4740
13
 * See the License for the specific language governing permissions and
4741
14
 * limitations under the License.
4742
15
 */
4743
16
4744
17
#define LOG_TAG "InputListener"
4745
18
4746
19
//#define LOG_NDEBUG 0
4747
20
4748
21
#include "InputListener.h"
4749
22
4750
23
#include <cutils/log.h>
4751
24
4752
25
namespace android {
4753
26
4754
27
// --- NotifyConfigurationChangedArgs ---
4755
28
4756
29
NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(std::chrono::nanoseconds eventTime) :
4757
30
        eventTime(eventTime) {
4758
31
}
4759
32
4760
33
NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(
4761
34
        const NotifyConfigurationChangedArgs& other) :
4762
35
        eventTime(other.eventTime) {
4763
36
}
4764
37
4765
38
void NotifyConfigurationChangedArgs::notify(InputListenerInterface& listener) const {
4766
39
    listener.notifyConfigurationChanged(this);
4767
40
}
4768
41
4769
42
4770
43
// --- NotifyKeyArgs ---
4771
44
4772
45
NotifyKeyArgs::NotifyKeyArgs(std::chrono::nanoseconds eventTime, uint64_t mac,
4773
46
        int32_t deviceId, uint32_t source, uint32_t policyFlags,
4774
47
        int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,
4775
48
        int32_t metaState, std::chrono::nanoseconds downTime) :
4776
49
        eventTime(eventTime), deviceId(deviceId), source(source), policyFlags(policyFlags),
4777
50
        action(action), flags(flags), keyCode(keyCode), scanCode(scanCode),
4778
51
        metaState(metaState), downTime(downTime) {
4779
52
}
4780
53
4781
54
NotifyKeyArgs::NotifyKeyArgs(const NotifyKeyArgs& other) :
4782
55
        eventTime(other.eventTime), mac(other.mac),
4783
56
        deviceId(other.deviceId), source(other.source),
4784
57
        policyFlags(other.policyFlags),
4785
58
        action(other.action), flags(other.flags),
4786
59
        keyCode(other.keyCode), scanCode(other.scanCode),
4787
60
        metaState(other.metaState), downTime(other.downTime) {
4788
61
}
4789
62
4790
63
void NotifyKeyArgs::notify(InputListenerInterface& listener) const {
4791
64
    listener.notifyKey(this);
4792
65
}
4793
66
4794
67
4795
68
// --- NotifyMotionArgs ---
4796
69
4797
70
NotifyMotionArgs::NotifyMotionArgs(std::chrono::nanoseconds eventTime, uint64_t mac,
4798
71
        int32_t deviceId, uint32_t source, uint32_t policyFlags,
4799
72
        int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
4800
73
        int32_t edgeFlags, uint32_t pointerCount,
4801
74
        const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
4802
75
        float xPrecision, float yPrecision, std::chrono::nanoseconds downTime) :
4803
76
        eventTime(eventTime), mac(mac), deviceId(deviceId), source(source),
4804
77
        policyFlags(policyFlags), action(action), flags(flags), metaState(metaState),
4805
78
        buttonState(buttonState), edgeFlags(edgeFlags), pointerCount(pointerCount),
4806
79
        xPrecision(xPrecision), yPrecision(yPrecision), downTime(downTime) {
4807
80
    for (uint32_t i = 0; i < pointerCount; i++) {
4808
81
        this->pointerProperties[i].copyFrom(pointerProperties[i]);
4809
82
        this->pointerCoords[i].copyFrom(pointerCoords[i]);
4810
83
    }
4811
84
}
4812
85
4813
86
NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other) :
4814
87
        eventTime(other.eventTime), mac(other.mac),
4815
88
        deviceId(other.deviceId), source(other.source),
4816
89
        policyFlags(other.policyFlags),
4817
90
        action(other.action), flags(other.flags),
4818
91
        metaState(other.metaState), buttonState(other.buttonState),
4819
92
        edgeFlags(other.edgeFlags), pointerCount(other.pointerCount),
4820
93
        xPrecision(other.xPrecision), yPrecision(other.yPrecision), downTime(other.downTime) {
4821
94
    for (uint32_t i = 0; i < pointerCount; i++) {
4822
95
        pointerProperties[i].copyFrom(other.pointerProperties[i]);
4823
96
        pointerCoords[i].copyFrom(other.pointerCoords[i]);
4824
97
    }
4825
98
}
4826
99
4827
100
void NotifyMotionArgs::notify(InputListenerInterface& listener) const {
4828
101
    listener.notifyMotion(this);
4829
102
}
4830
103
4831
104
4832
105
// --- NotifySwitchArgs ---
4833
106
4834
107
NotifySwitchArgs::NotifySwitchArgs(std::chrono::nanoseconds eventTime, uint32_t policyFlags,
4835
108
        int32_t switchCode, int32_t switchValue) :
4836
109
        eventTime(eventTime), policyFlags(policyFlags),
4837
110
        switchCode(switchCode), switchValue(switchValue) {
4838
111
}
4839
112
4840
113
NotifySwitchArgs::NotifySwitchArgs(const NotifySwitchArgs& other) :
4841
114
        eventTime(other.eventTime), policyFlags(other.policyFlags),
4842
115
        switchCode(other.switchCode), switchValue(other.switchValue) {
4843
116
}
4844
117
4845
118
void NotifySwitchArgs::notify(InputListenerInterface& listener) const {
4846
119
    listener.notifySwitch(this);
4847
120
}
4848
121
4849
122
4850
123
// --- NotifyDeviceResetArgs ---
4851
124
4852
125
NotifyDeviceResetArgs::NotifyDeviceResetArgs(std::chrono::nanoseconds eventTime, int32_t deviceId) :
4853
126
        eventTime(eventTime), deviceId(deviceId) {
4854
127
}
4855
128
4856
129
NotifyDeviceResetArgs::NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other) :
4857
130
        eventTime(other.eventTime), deviceId(other.deviceId) {
4858
131
}
4859
132
4860
133
void NotifyDeviceResetArgs::notify(InputListenerInterface& listener) const {
4861
134
    listener.notifyDeviceReset(this);
4862
135
}
4863
136
4864
137
4865
138
// --- QueuedInputListener ---
4866
139
4867
140
QueuedInputListener::QueuedInputListener(const std::shared_ptr<InputListenerInterface>& innerListener) :
4868
141
        mInnerListener(innerListener) {
4869
142
}
4870
143
4871
144
QueuedInputListener::~QueuedInputListener() {
4872
145
    size_t count = mArgsQueue.size();
4873
146
    for (size_t i = 0; i < count; i++) {
4874
147
        delete mArgsQueue[i];
4875
148
    }
4876
149
}
4877
150
4878
151
void QueuedInputListener::notifyConfigurationChanged(
4879
152
        const NotifyConfigurationChangedArgs* args) {
4880
153
    mArgsQueue.push(new NotifyConfigurationChangedArgs(*args));
4881
154
}
4882
155
4883
156
void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {
4884
157
    mArgsQueue.push(new NotifyKeyArgs(*args));
4885
158
}
4886
159
4887
160
void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
4888
161
    mArgsQueue.push(new NotifyMotionArgs(*args));
4889
162
}
4890
163
4891
164
void QueuedInputListener::notifySwitch(const NotifySwitchArgs* args) {
4892
165
    mArgsQueue.push(new NotifySwitchArgs(*args));
4893
166
}
4894
167
4895
168
void QueuedInputListener::notifyDeviceReset(const NotifyDeviceResetArgs* args) {
4896
169
    mArgsQueue.push(new NotifyDeviceResetArgs(*args));
4897
170
}
4898
171
4899
172
void QueuedInputListener::flush() {
4900
173
    size_t count = mArgsQueue.size();
4901
174
    for (size_t i = 0; i < count; i++) {
4902
175
        NotifyArgs* args = mArgsQueue[i];
4903
176
        args->notify(*mInnerListener);
4904
177
        delete args;
4905
178
    }
4906
179
    mArgsQueue.clear();
4907
180
}
4908
181
4909
182
4910
183
} // namespace android
4911
184
0
4912
=== removed file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
4913
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2015-09-24 15:42:21 +0000
4914
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	1970-01-01 00:00:00 +0000
4915
@@ -1,6356 +0,0 @@
4916
1
/*
4917
2
 * Copyright (C) 2010 The Android Open Source Project
4918
3
 *
4919
4
 * Licensed under the Apache License, Version 2.0 (the "License");
4920
5
 * you may not use this file except in compliance with the License.
4921
6
 * You may obtain a copy of the License at
4922
7
 *
4923
8
 *      http://www.apache.org/licenses/LICENSE-2.0
4924
9
 *
4925
10
 * Unless required by applicable law or agreed to in writing, software
4926
11
 * distributed under the License is distributed on an "AS IS" BASIS,
4927
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4928
13
 * See the License for the specific language governing permissions and
4929
14
 * limitations under the License.
4930
15
 */
4931
16
4932
17
#define LOG_TAG "InputReader"
4933
18
4934
19
//#define LOG_NDEBUG 0
4935
20
4936
21
// Log debug messages for each raw event received from the EventHub.
4937
22
#define DEBUG_RAW_EVENTS 0
4938
23
4939
24
// Log debug messages about touch screen filtering hacks.
4940
25
#define DEBUG_HACKS 0
4941
26
4942
27
// Log debug messages about virtual key processing.
4943
28
#define DEBUG_VIRTUAL_KEYS 0
4944
29
4945
30
// Log debug messages about pointers.
4946
31
#define DEBUG_POINTERS 0
4947
32
4948
33
// Log debug messages about pointer assignment calculations.
4949
34
#define DEBUG_POINTER_ASSIGNMENT 0
4950
35
4951
36
// Log debug messages about gesture detection.
4952
37
#define DEBUG_GESTURES 0
4953
38
4954
39
// Log debug messages about the vibrator.
4955
40
#define DEBUG_VIBRATOR 0
4956
41
4957
42
#include "InputReader.h"
4958
43
4959
44
#include <cutils/log.h>
4960
45
#include <androidfw/Keyboard.h>
4961
46
#include <androidfw/VirtualKeyMap.h>
4962
47
4963
48
#include <android/keycodes.h>
4964
49
4965
50
#include <std/BitSet.h>
4966
51
4967
52
#include <stddef.h>
4968
53
#include <stdlib.h>
4969
54
#include <unistd.h>
4970
55
#include <errno.h>
4971
56
#include <limits.h>
4972
57
#include <math.h>
4973
58
4974
59
#if DEBUG_RAW_EVENTS
4975
60
#include "InputEventPrinter.h"
4976
61
#endif
4977
62
4978
63
#define INDENT "  "
4979
64
#define INDENT2 "    "
4980
65
#define INDENT3 "      "
4981
66
#define INDENT4 "        "
4982
67
#define INDENT5 "          "
4983
68
4984
69
namespace android {
4985
70
4986
71
// --- Constants ---
4987
72
4988
73
// Maximum number of slots supported when using the slot-based Multitouch Protocol B.
4989
74
static const size_t MAX_SLOTS = 32;
4990
75
4991
76
// --- Static Functions ---
4992
77
4993
78
template<typename T>
4994
79
inline static T min(const T& a, const T& b) {
4995
80
    return a < b ? a : b;
4996
81
}
4997
82
4998
83
template<typename T>
4999
84
inline static void swap(T& a, T& b) {
5000
85
    T temp = a;
Reviewer	Review Type	Date Requested	Status
Andreas Pokorny (community)			Approve on 2015-12-17
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2015-12-16
Daniel van Vugt		2015-12-01	Abstain on 2015-12-16
Alberto Aguirre (community)			Abstain on 2015-12-09
Review via email: mp+279111@code.launchpad.net