1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "KeyCharacterMap"
18 
19 #include <stdlib.h>
20 #include <string.h>
21 
22 #ifdef __ANDROID__
23 #include <binder/Parcel.h>
24 #endif
25 
26 #include <android/keycodes.h>
27 #include <input/InputEventLabels.h>
28 #include <input/Keyboard.h>
29 #include <input/KeyCharacterMap.h>
30 
31 #include <utils/Log.h>
32 #include <utils/Errors.h>
33 #include <utils/Tokenizer.h>
34 #include <utils/Timers.h>
35 
36 // Enables debug output for the parser.
37 #define DEBUG_PARSER 0
38 
39 // Enables debug output for parser performance.
40 #define DEBUG_PARSER_PERFORMANCE 0
41 
42 // Enables debug output for mapping.
43 #define DEBUG_MAPPING 0
44 
45 
46 namespace android {
47 
48 static const char* WHITESPACE = " \t\r";
49 static const char* WHITESPACE_OR_PROPERTY_DELIMITER = " \t\r,:";
50 
51 struct Modifier {
52     const char* label;
53     int32_t metaState;
54 };
55 static const Modifier modifiers[] = {
56         { "shift", AMETA_SHIFT_ON },
57         { "lshift", AMETA_SHIFT_LEFT_ON },
58         { "rshift", AMETA_SHIFT_RIGHT_ON },
59         { "alt", AMETA_ALT_ON },
60         { "lalt", AMETA_ALT_LEFT_ON },
61         { "ralt", AMETA_ALT_RIGHT_ON },
62         { "ctrl", AMETA_CTRL_ON },
63         { "lctrl", AMETA_CTRL_LEFT_ON },
64         { "rctrl", AMETA_CTRL_RIGHT_ON },
65         { "meta", AMETA_META_ON },
66         { "lmeta", AMETA_META_LEFT_ON },
67         { "rmeta", AMETA_META_RIGHT_ON },
68         { "sym", AMETA_SYM_ON },
69         { "fn", AMETA_FUNCTION_ON },
70         { "capslock", AMETA_CAPS_LOCK_ON },
71         { "numlock", AMETA_NUM_LOCK_ON },
72         { "scrolllock", AMETA_SCROLL_LOCK_ON },
73 };
74 
75 #if DEBUG_MAPPING
toString(const char16_t * chars,size_t numChars)76 static String8 toString(const char16_t* chars, size_t numChars) {
77     String8 result;
78     for (size_t i = 0; i < numChars; i++) {
79         result.appendFormat(i == 0 ? "%d" : ", %d", chars[i]);
80     }
81     return result;
82 }
83 #endif
84 
85 
86 // --- KeyCharacterMap ---
87 
88 sp<KeyCharacterMap> KeyCharacterMap::sEmpty = new KeyCharacterMap();
89 
KeyCharacterMap()90 KeyCharacterMap::KeyCharacterMap() :
91     mType(KEYBOARD_TYPE_UNKNOWN) {
92 }
93 
KeyCharacterMap(const KeyCharacterMap & other)94 KeyCharacterMap::KeyCharacterMap(const KeyCharacterMap& other) :
95     RefBase(), mType(other.mType), mKeysByScanCode(other.mKeysByScanCode),
96     mKeysByUsageCode(other.mKeysByUsageCode) {
97     for (size_t i = 0; i < other.mKeys.size(); i++) {
98         mKeys.add(other.mKeys.keyAt(i), new Key(*other.mKeys.valueAt(i)));
99     }
100 }
101 
~KeyCharacterMap()102 KeyCharacterMap::~KeyCharacterMap() {
103     for (size_t i = 0; i < mKeys.size(); i++) {
104         Key* key = mKeys.editValueAt(i);
105         delete key;
106     }
107 }
108 
load(const std::string & filename,Format format,sp<KeyCharacterMap> * outMap)109 status_t KeyCharacterMap::load(const std::string& filename,
110         Format format, sp<KeyCharacterMap>* outMap) {
111     outMap->clear();
112 
113     Tokenizer* tokenizer;
114     status_t status = Tokenizer::open(String8(filename.c_str()), &tokenizer);
115     if (status) {
116         ALOGE("Error %d opening key character map file %s.", status, filename.c_str());
117     } else {
118         status = load(tokenizer, format, outMap);
119         delete tokenizer;
120     }
121     return status;
122 }
123 
loadContents(const std::string & filename,const char * contents,Format format,sp<KeyCharacterMap> * outMap)124 status_t KeyCharacterMap::loadContents(const std::string& filename, const char* contents,
125         Format format, sp<KeyCharacterMap>* outMap) {
126     outMap->clear();
127 
128     Tokenizer* tokenizer;
129     status_t status = Tokenizer::fromContents(String8(filename.c_str()), contents, &tokenizer);
130     if (status) {
131         ALOGE("Error %d opening key character map.", status);
132     } else {
133         status = load(tokenizer, format, outMap);
134         delete tokenizer;
135     }
136     return status;
137 }
138 
load(Tokenizer * tokenizer,Format format,sp<KeyCharacterMap> * outMap)139 status_t KeyCharacterMap::load(Tokenizer* tokenizer,
140         Format format, sp<KeyCharacterMap>* outMap) {
141     status_t status = OK;
142     sp<KeyCharacterMap> map = new KeyCharacterMap();
143     if (!map.get()) {
144         ALOGE("Error allocating key character map.");
145         status = NO_MEMORY;
146     } else {
147 #if DEBUG_PARSER_PERFORMANCE
148         nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
149 #endif
150         Parser parser(map.get(), tokenizer, format);
151         status = parser.parse();
152 #if DEBUG_PARSER_PERFORMANCE
153         nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
154         ALOGD("Parsed key character map file '%s' %d lines in %0.3fms.",
155                 tokenizer->getFilename().string(), tokenizer->getLineNumber(),
156                 elapsedTime / 1000000.0);
157 #endif
158         if (!status) {
159             *outMap = map;
160         }
161     }
162     return status;
163 }
164 
combine(const sp<KeyCharacterMap> & base,const sp<KeyCharacterMap> & overlay)165 sp<KeyCharacterMap> KeyCharacterMap::combine(const sp<KeyCharacterMap>& base,
166         const sp<KeyCharacterMap>& overlay) {
167     if (overlay == nullptr) {
168         return base;
169     }
170     if (base == nullptr) {
171         return overlay;
172     }
173 
174     sp<KeyCharacterMap> map = new KeyCharacterMap(*base.get());
175     for (size_t i = 0; i < overlay->mKeys.size(); i++) {
176         int32_t keyCode = overlay->mKeys.keyAt(i);
177         Key* key = overlay->mKeys.valueAt(i);
178         ssize_t oldIndex = map->mKeys.indexOfKey(keyCode);
179         if (oldIndex >= 0) {
180             delete map->mKeys.valueAt(oldIndex);
181             map->mKeys.editValueAt(oldIndex) = new Key(*key);
182         } else {
183             map->mKeys.add(keyCode, new Key(*key));
184         }
185     }
186 
187     for (size_t i = 0; i < overlay->mKeysByScanCode.size(); i++) {
188         map->mKeysByScanCode.replaceValueFor(overlay->mKeysByScanCode.keyAt(i),
189                 overlay->mKeysByScanCode.valueAt(i));
190     }
191 
192     for (size_t i = 0; i < overlay->mKeysByUsageCode.size(); i++) {
193         map->mKeysByUsageCode.replaceValueFor(overlay->mKeysByUsageCode.keyAt(i),
194                 overlay->mKeysByUsageCode.valueAt(i));
195     }
196     return map;
197 }
198 
empty()199 sp<KeyCharacterMap> KeyCharacterMap::empty() {
200     return sEmpty;
201 }
202 
getKeyboardType() const203 int32_t KeyCharacterMap::getKeyboardType() const {
204     return mType;
205 }
206 
getDisplayLabel(int32_t keyCode) const207 char16_t KeyCharacterMap::getDisplayLabel(int32_t keyCode) const {
208     char16_t result = 0;
209     const Key* key;
210     if (getKey(keyCode, &key)) {
211         result = key->label;
212     }
213 #if DEBUG_MAPPING
214     ALOGD("getDisplayLabel: keyCode=%d ~ Result %d.", keyCode, result);
215 #endif
216     return result;
217 }
218 
getNumber(int32_t keyCode) const219 char16_t KeyCharacterMap::getNumber(int32_t keyCode) const {
220     char16_t result = 0;
221     const Key* key;
222     if (getKey(keyCode, &key)) {
223         result = key->number;
224     }
225 #if DEBUG_MAPPING
226     ALOGD("getNumber: keyCode=%d ~ Result %d.", keyCode, result);
227 #endif
228     return result;
229 }
230 
getCharacter(int32_t keyCode,int32_t metaState) const231 char16_t KeyCharacterMap::getCharacter(int32_t keyCode, int32_t metaState) const {
232     char16_t result = 0;
233     const Key* key;
234     const Behavior* behavior;
235     if (getKeyBehavior(keyCode, metaState, &key, &behavior)) {
236         result = behavior->character;
237     }
238 #if DEBUG_MAPPING
239     ALOGD("getCharacter: keyCode=%d, metaState=0x%08x ~ Result %d.", keyCode, metaState, result);
240 #endif
241     return result;
242 }
243 
getFallbackAction(int32_t keyCode,int32_t metaState,FallbackAction * outFallbackAction) const244 bool KeyCharacterMap::getFallbackAction(int32_t keyCode, int32_t metaState,
245         FallbackAction* outFallbackAction) const {
246     outFallbackAction->keyCode = 0;
247     outFallbackAction->metaState = 0;
248 
249     bool result = false;
250     const Key* key;
251     const Behavior* behavior;
252     if (getKeyBehavior(keyCode, metaState, &key, &behavior)) {
253         if (behavior->fallbackKeyCode) {
254             outFallbackAction->keyCode = behavior->fallbackKeyCode;
255             outFallbackAction->metaState = metaState & ~behavior->metaState;
256             result = true;
257         }
258     }
259 #if DEBUG_MAPPING
260     ALOGD("getFallbackKeyCode: keyCode=%d, metaState=0x%08x ~ Result %s, "
261             "fallback keyCode=%d, fallback metaState=0x%08x.",
262             keyCode, metaState, result ? "true" : "false",
263             outFallbackAction->keyCode, outFallbackAction->metaState);
264 #endif
265     return result;
266 }
267 
getMatch(int32_t keyCode,const char16_t * chars,size_t numChars,int32_t metaState) const268 char16_t KeyCharacterMap::getMatch(int32_t keyCode, const char16_t* chars, size_t numChars,
269         int32_t metaState) const {
270     char16_t result = 0;
271     const Key* key;
272     if (getKey(keyCode, &key)) {
273         // Try to find the most general behavior that maps to this character.
274         // For example, the base key behavior will usually be last in the list.
275         // However, if we find a perfect meta state match for one behavior then use that one.
276         for (const Behavior* behavior = key->firstBehavior; behavior; behavior = behavior->next) {
277             if (behavior->character) {
278                 for (size_t i = 0; i < numChars; i++) {
279                     if (behavior->character == chars[i]) {
280                         result = behavior->character;
281                         if ((behavior->metaState & metaState) == behavior->metaState) {
282                             goto ExactMatch;
283                         }
284                         break;
285                     }
286                 }
287             }
288         }
289     ExactMatch: ;
290     }
291 #if DEBUG_MAPPING
292     ALOGD("getMatch: keyCode=%d, chars=[%s], metaState=0x%08x ~ Result %d.",
293             keyCode, toString(chars, numChars).string(), metaState, result);
294 #endif
295     return result;
296 }
297 
getEvents(int32_t deviceId,const char16_t * chars,size_t numChars,Vector<KeyEvent> & outEvents) const298 bool KeyCharacterMap::getEvents(int32_t deviceId, const char16_t* chars, size_t numChars,
299         Vector<KeyEvent>& outEvents) const {
300     nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
301 
302     for (size_t i = 0; i < numChars; i++) {
303         int32_t keyCode, metaState;
304         char16_t ch = chars[i];
305         if (!findKey(ch, &keyCode, &metaState)) {
306 #if DEBUG_MAPPING
307             ALOGD("getEvents: deviceId=%d, chars=[%s] ~ Failed to find mapping for character %d.",
308                     deviceId, toString(chars, numChars).string(), ch);
309 #endif
310             return false;
311         }
312 
313         int32_t currentMetaState = 0;
314         addMetaKeys(outEvents, deviceId, metaState, true, now, &currentMetaState);
315         addKey(outEvents, deviceId, keyCode, currentMetaState, true, now);
316         addKey(outEvents, deviceId, keyCode, currentMetaState, false, now);
317         addMetaKeys(outEvents, deviceId, metaState, false, now, &currentMetaState);
318     }
319 #if DEBUG_MAPPING
320     ALOGD("getEvents: deviceId=%d, chars=[%s] ~ Generated %d events.",
321             deviceId, toString(chars, numChars).string(), int32_t(outEvents.size()));
322     for (size_t i = 0; i < outEvents.size(); i++) {
323         ALOGD("  Key: keyCode=%d, metaState=0x%08x, %s.",
324                 outEvents[i].getKeyCode(), outEvents[i].getMetaState(),
325                 outEvents[i].getAction() == AKEY_EVENT_ACTION_DOWN ? "down" : "up");
326     }
327 #endif
328     return true;
329 }
330 
mapKey(int32_t scanCode,int32_t usageCode,int32_t * outKeyCode) const331 status_t KeyCharacterMap::mapKey(int32_t scanCode, int32_t usageCode, int32_t* outKeyCode) const {
332     if (usageCode) {
333         ssize_t index = mKeysByUsageCode.indexOfKey(usageCode);
334         if (index >= 0) {
335             *outKeyCode = mKeysByUsageCode.valueAt(index);
336 #if DEBUG_MAPPING
337             ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d.",
338                     scanCode, usageCode, *outKeyCode);
339 #endif
340             return OK;
341         }
342     }
343     if (scanCode) {
344         ssize_t index = mKeysByScanCode.indexOfKey(scanCode);
345         if (index >= 0) {
346             *outKeyCode = mKeysByScanCode.valueAt(index);
347 #if DEBUG_MAPPING
348             ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d.",
349                     scanCode, usageCode, *outKeyCode);
350 #endif
351             return OK;
352         }
353     }
354 
355 #if DEBUG_MAPPING
356     ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Failed.", scanCode, usageCode);
357 #endif
358     *outKeyCode = AKEYCODE_UNKNOWN;
359     return NAME_NOT_FOUND;
360 }
361 
tryRemapKey(int32_t keyCode,int32_t metaState,int32_t * outKeyCode,int32_t * outMetaState) const362 void KeyCharacterMap::tryRemapKey(int32_t keyCode, int32_t metaState,
363                                   int32_t *outKeyCode, int32_t *outMetaState) const {
364     *outKeyCode = keyCode;
365     *outMetaState = metaState;
366 
367     const Key* key;
368     const Behavior* behavior;
369     if (getKeyBehavior(keyCode, metaState, &key, &behavior)) {
370         if (behavior->replacementKeyCode) {
371             *outKeyCode = behavior->replacementKeyCode;
372             int32_t newMetaState = metaState & ~behavior->metaState;
373             // Reset dependent meta states.
374             if (behavior->metaState & AMETA_ALT_ON) {
375                 newMetaState &= ~(AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON);
376             }
377             if (behavior->metaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
378                 newMetaState &= ~AMETA_ALT_ON;
379             }
380             if (behavior->metaState & AMETA_CTRL_ON) {
381                 newMetaState &= ~(AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON);
382             }
383             if (behavior->metaState & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
384                 newMetaState &= ~AMETA_CTRL_ON;
385             }
386             if (behavior->metaState & AMETA_SHIFT_ON) {
387                 newMetaState &= ~(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON);
388             }
389             if (behavior->metaState & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
390                 newMetaState &= ~AMETA_SHIFT_ON;
391             }
392             // ... and put universal bits back if needed
393             *outMetaState = normalizeMetaState(newMetaState);
394         }
395     }
396 
397 #if DEBUG_MAPPING
398     ALOGD("tryRemapKey: keyCode=%d, metaState=0x%08x ~ "
399             "replacement keyCode=%d, replacement metaState=0x%08x.",
400             keyCode, metaState, *outKeyCode, *outMetaState);
401 #endif
402 }
403 
getKey(int32_t keyCode,const Key ** outKey) const404 bool KeyCharacterMap::getKey(int32_t keyCode, const Key** outKey) const {
405     ssize_t index = mKeys.indexOfKey(keyCode);
406     if (index >= 0) {
407         *outKey = mKeys.valueAt(index);
408         return true;
409     }
410     return false;
411 }
412 
getKeyBehavior(int32_t keyCode,int32_t metaState,const Key ** outKey,const Behavior ** outBehavior) const413 bool KeyCharacterMap::getKeyBehavior(int32_t keyCode, int32_t metaState,
414         const Key** outKey, const Behavior** outBehavior) const {
415     const Key* key;
416     if (getKey(keyCode, &key)) {
417         const Behavior* behavior = key->firstBehavior;
418         while (behavior) {
419             if (matchesMetaState(metaState, behavior->metaState)) {
420                 *outKey = key;
421                 *outBehavior = behavior;
422                 return true;
423             }
424             behavior = behavior->next;
425         }
426     }
427     return false;
428 }
429 
matchesMetaState(int32_t eventMetaState,int32_t behaviorMetaState)430 bool KeyCharacterMap::matchesMetaState(int32_t eventMetaState, int32_t behaviorMetaState) {
431     // Behavior must have at least the set of meta states specified.
432     // And if the key event has CTRL, ALT or META then the behavior must exactly
433     // match those, taking into account that a behavior can specify that it handles
434     // one, both or either of a left/right modifier pair.
435     if ((eventMetaState & behaviorMetaState) == behaviorMetaState) {
436         const int32_t EXACT_META_STATES =
437                 AMETA_CTRL_ON | AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON
438                 | AMETA_ALT_ON | AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON
439                 | AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON;
440         int32_t unmatchedMetaState = eventMetaState & ~behaviorMetaState & EXACT_META_STATES;
441         if (behaviorMetaState & AMETA_CTRL_ON) {
442             unmatchedMetaState &= ~(AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON);
443         } else if (behaviorMetaState & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
444             unmatchedMetaState &= ~AMETA_CTRL_ON;
445         }
446         if (behaviorMetaState & AMETA_ALT_ON) {
447             unmatchedMetaState &= ~(AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON);
448         } else if (behaviorMetaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
449             unmatchedMetaState &= ~AMETA_ALT_ON;
450         }
451         if (behaviorMetaState & AMETA_META_ON) {
452             unmatchedMetaState &= ~(AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
453         } else if (behaviorMetaState & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
454             unmatchedMetaState &= ~AMETA_META_ON;
455         }
456         return !unmatchedMetaState;
457     }
458     return false;
459 }
460 
findKey(char16_t ch,int32_t * outKeyCode,int32_t * outMetaState) const461 bool KeyCharacterMap::findKey(char16_t ch, int32_t* outKeyCode, int32_t* outMetaState) const {
462     if (!ch) {
463         return false;
464     }
465 
466     for (size_t i = 0; i < mKeys.size(); i++) {
467         const Key* key = mKeys.valueAt(i);
468 
469         // Try to find the most general behavior that maps to this character.
470         // For example, the base key behavior will usually be last in the list.
471         const Behavior* found = nullptr;
472         for (const Behavior* behavior = key->firstBehavior; behavior; behavior = behavior->next) {
473             if (behavior->character == ch) {
474                 found = behavior;
475             }
476         }
477         if (found) {
478             *outKeyCode = mKeys.keyAt(i);
479             *outMetaState = found->metaState;
480             return true;
481         }
482     }
483     return false;
484 }
485 
addKey(Vector<KeyEvent> & outEvents,int32_t deviceId,int32_t keyCode,int32_t metaState,bool down,nsecs_t time)486 void KeyCharacterMap::addKey(Vector<KeyEvent>& outEvents,
487         int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time) {
488     outEvents.push();
489     KeyEvent& event = outEvents.editTop();
490     event.initialize(deviceId, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,
491             down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
492             0, keyCode, 0, metaState, 0, time, time);
493 }
494 
addMetaKeys(Vector<KeyEvent> & outEvents,int32_t deviceId,int32_t metaState,bool down,nsecs_t time,int32_t * currentMetaState)495 void KeyCharacterMap::addMetaKeys(Vector<KeyEvent>& outEvents,
496         int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
497         int32_t* currentMetaState) {
498     // Add and remove meta keys symmetrically.
499     if (down) {
500         addLockedMetaKey(outEvents, deviceId, metaState, time,
501                 AKEYCODE_CAPS_LOCK, AMETA_CAPS_LOCK_ON, currentMetaState);
502         addLockedMetaKey(outEvents, deviceId, metaState, time,
503                 AKEYCODE_NUM_LOCK, AMETA_NUM_LOCK_ON, currentMetaState);
504         addLockedMetaKey(outEvents, deviceId, metaState, time,
505                 AKEYCODE_SCROLL_LOCK, AMETA_SCROLL_LOCK_ON, currentMetaState);
506 
507         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
508                 AKEYCODE_SHIFT_LEFT, AMETA_SHIFT_LEFT_ON,
509                 AKEYCODE_SHIFT_RIGHT, AMETA_SHIFT_RIGHT_ON,
510                 AMETA_SHIFT_ON, currentMetaState);
511         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
512                 AKEYCODE_ALT_LEFT, AMETA_ALT_LEFT_ON,
513                 AKEYCODE_ALT_RIGHT, AMETA_ALT_RIGHT_ON,
514                 AMETA_ALT_ON, currentMetaState);
515         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
516                 AKEYCODE_CTRL_LEFT, AMETA_CTRL_LEFT_ON,
517                 AKEYCODE_CTRL_RIGHT, AMETA_CTRL_RIGHT_ON,
518                 AMETA_CTRL_ON, currentMetaState);
519         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
520                 AKEYCODE_META_LEFT, AMETA_META_LEFT_ON,
521                 AKEYCODE_META_RIGHT, AMETA_META_RIGHT_ON,
522                 AMETA_META_ON, currentMetaState);
523 
524         addSingleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
525                 AKEYCODE_SYM, AMETA_SYM_ON, currentMetaState);
526         addSingleEphemeralMetaKey(outEvents, deviceId, metaState, true, time,
527                 AKEYCODE_FUNCTION, AMETA_FUNCTION_ON, currentMetaState);
528     } else {
529         addSingleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
530                 AKEYCODE_FUNCTION, AMETA_FUNCTION_ON, currentMetaState);
531         addSingleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
532                 AKEYCODE_SYM, AMETA_SYM_ON, currentMetaState);
533 
534         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
535                 AKEYCODE_META_LEFT, AMETA_META_LEFT_ON,
536                 AKEYCODE_META_RIGHT, AMETA_META_RIGHT_ON,
537                 AMETA_META_ON, currentMetaState);
538         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
539                 AKEYCODE_CTRL_LEFT, AMETA_CTRL_LEFT_ON,
540                 AKEYCODE_CTRL_RIGHT, AMETA_CTRL_RIGHT_ON,
541                 AMETA_CTRL_ON, currentMetaState);
542         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
543                 AKEYCODE_ALT_LEFT, AMETA_ALT_LEFT_ON,
544                 AKEYCODE_ALT_RIGHT, AMETA_ALT_RIGHT_ON,
545                 AMETA_ALT_ON, currentMetaState);
546         addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time,
547                 AKEYCODE_SHIFT_LEFT, AMETA_SHIFT_LEFT_ON,
548                 AKEYCODE_SHIFT_RIGHT, AMETA_SHIFT_RIGHT_ON,
549                 AMETA_SHIFT_ON, currentMetaState);
550 
551         addLockedMetaKey(outEvents, deviceId, metaState, time,
552                 AKEYCODE_SCROLL_LOCK, AMETA_SCROLL_LOCK_ON, currentMetaState);
553         addLockedMetaKey(outEvents, deviceId, metaState, time,
554                 AKEYCODE_NUM_LOCK, AMETA_NUM_LOCK_ON, currentMetaState);
555         addLockedMetaKey(outEvents, deviceId, metaState, time,
556                 AKEYCODE_CAPS_LOCK, AMETA_CAPS_LOCK_ON, currentMetaState);
557     }
558 }
559 
addSingleEphemeralMetaKey(Vector<KeyEvent> & outEvents,int32_t deviceId,int32_t metaState,bool down,nsecs_t time,int32_t keyCode,int32_t keyMetaState,int32_t * currentMetaState)560 bool KeyCharacterMap::addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
561         int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
562         int32_t keyCode, int32_t keyMetaState,
563         int32_t* currentMetaState) {
564     if ((metaState & keyMetaState) == keyMetaState) {
565         *currentMetaState = updateMetaState(keyCode, down, *currentMetaState);
566         addKey(outEvents, deviceId, keyCode, *currentMetaState, down, time);
567         return true;
568     }
569     return false;
570 }
571 
addDoubleEphemeralMetaKey(Vector<KeyEvent> & outEvents,int32_t deviceId,int32_t metaState,bool down,nsecs_t time,int32_t leftKeyCode,int32_t leftKeyMetaState,int32_t rightKeyCode,int32_t rightKeyMetaState,int32_t eitherKeyMetaState,int32_t * currentMetaState)572 void KeyCharacterMap::addDoubleEphemeralMetaKey(Vector<KeyEvent>& outEvents,
573         int32_t deviceId, int32_t metaState, bool down, nsecs_t time,
574         int32_t leftKeyCode, int32_t leftKeyMetaState,
575         int32_t rightKeyCode, int32_t rightKeyMetaState,
576         int32_t eitherKeyMetaState,
577         int32_t* currentMetaState) {
578     bool specific = false;
579     specific |= addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time,
580             leftKeyCode, leftKeyMetaState, currentMetaState);
581     specific |= addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time,
582             rightKeyCode, rightKeyMetaState, currentMetaState);
583 
584     if (!specific) {
585         addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time,
586                 leftKeyCode, eitherKeyMetaState, currentMetaState);
587     }
588 }
589 
addLockedMetaKey(Vector<KeyEvent> & outEvents,int32_t deviceId,int32_t metaState,nsecs_t time,int32_t keyCode,int32_t keyMetaState,int32_t * currentMetaState)590 void KeyCharacterMap::addLockedMetaKey(Vector<KeyEvent>& outEvents,
591         int32_t deviceId, int32_t metaState, nsecs_t time,
592         int32_t keyCode, int32_t keyMetaState,
593         int32_t* currentMetaState) {
594     if ((metaState & keyMetaState) == keyMetaState) {
595         *currentMetaState = updateMetaState(keyCode, true, *currentMetaState);
596         addKey(outEvents, deviceId, keyCode, *currentMetaState, true, time);
597         *currentMetaState = updateMetaState(keyCode, false, *currentMetaState);
598         addKey(outEvents, deviceId, keyCode, *currentMetaState, false, time);
599     }
600 }
601 
602 #ifdef __ANDROID__
readFromParcel(Parcel * parcel)603 sp<KeyCharacterMap> KeyCharacterMap::readFromParcel(Parcel* parcel) {
604     sp<KeyCharacterMap> map = new KeyCharacterMap();
605     map->mType = parcel->readInt32();
606     size_t numKeys = parcel->readInt32();
607     if (parcel->errorCheck()) {
608         return nullptr;
609     }
610     if (numKeys > MAX_KEYS) {
611         ALOGE("Too many keys in KeyCharacterMap (%zu > %d)", numKeys, MAX_KEYS);
612         return nullptr;
613     }
614 
615     for (size_t i = 0; i < numKeys; i++) {
616         int32_t keyCode = parcel->readInt32();
617         char16_t label = parcel->readInt32();
618         char16_t number = parcel->readInt32();
619         if (parcel->errorCheck()) {
620             return nullptr;
621         }
622 
623         Key* key = new Key();
624         key->label = label;
625         key->number = number;
626         map->mKeys.add(keyCode, key);
627 
628         Behavior* lastBehavior = nullptr;
629         while (parcel->readInt32()) {
630             int32_t metaState = parcel->readInt32();
631             char16_t character = parcel->readInt32();
632             int32_t fallbackKeyCode = parcel->readInt32();
633             int32_t replacementKeyCode = parcel->readInt32();
634             if (parcel->errorCheck()) {
635                 return nullptr;
636             }
637 
638             Behavior* behavior = new Behavior();
639             behavior->metaState = metaState;
640             behavior->character = character;
641             behavior->fallbackKeyCode = fallbackKeyCode;
642             behavior->replacementKeyCode = replacementKeyCode;
643             if (lastBehavior) {
644                 lastBehavior->next = behavior;
645             } else {
646                 key->firstBehavior = behavior;
647             }
648             lastBehavior = behavior;
649         }
650 
651         if (parcel->errorCheck()) {
652             return nullptr;
653         }
654     }
655     return map;
656 }
657 
writeToParcel(Parcel * parcel) const658 void KeyCharacterMap::writeToParcel(Parcel* parcel) const {
659     parcel->writeInt32(mType);
660 
661     size_t numKeys = mKeys.size();
662     parcel->writeInt32(numKeys);
663     for (size_t i = 0; i < numKeys; i++) {
664         int32_t keyCode = mKeys.keyAt(i);
665         const Key* key = mKeys.valueAt(i);
666         parcel->writeInt32(keyCode);
667         parcel->writeInt32(key->label);
668         parcel->writeInt32(key->number);
669         for (const Behavior* behavior = key->firstBehavior; behavior != nullptr;
670                 behavior = behavior->next) {
671             parcel->writeInt32(1);
672             parcel->writeInt32(behavior->metaState);
673             parcel->writeInt32(behavior->character);
674             parcel->writeInt32(behavior->fallbackKeyCode);
675             parcel->writeInt32(behavior->replacementKeyCode);
676         }
677         parcel->writeInt32(0);
678     }
679 }
680 #endif
681 
682 
683 // --- KeyCharacterMap::Key ---
684 
Key()685 KeyCharacterMap::Key::Key() :
686         label(0), number(0), firstBehavior(nullptr) {
687 }
688 
Key(const Key & other)689 KeyCharacterMap::Key::Key(const Key& other) :
690         label(other.label), number(other.number),
691         firstBehavior(other.firstBehavior ? new Behavior(*other.firstBehavior) : nullptr) {
692 }
693 
~Key()694 KeyCharacterMap::Key::~Key() {
695     Behavior* behavior = firstBehavior;
696     while (behavior) {
697         Behavior* next = behavior->next;
698         delete behavior;
699         behavior = next;
700     }
701 }
702 
703 
704 // --- KeyCharacterMap::Behavior ---
705 
Behavior()706 KeyCharacterMap::Behavior::Behavior() :
707         next(nullptr), metaState(0), character(0), fallbackKeyCode(0), replacementKeyCode(0) {
708 }
709 
Behavior(const Behavior & other)710 KeyCharacterMap::Behavior::Behavior(const Behavior& other) :
711         next(other.next ? new Behavior(*other.next) : nullptr),
712         metaState(other.metaState), character(other.character),
713         fallbackKeyCode(other.fallbackKeyCode),
714         replacementKeyCode(other.replacementKeyCode) {
715 }
716 
717 
718 // --- KeyCharacterMap::Parser ---
719 
Parser(KeyCharacterMap * map,Tokenizer * tokenizer,Format format)720 KeyCharacterMap::Parser::Parser(KeyCharacterMap* map, Tokenizer* tokenizer, Format format) :
721         mMap(map), mTokenizer(tokenizer), mFormat(format), mState(STATE_TOP) {
722 }
723 
~Parser()724 KeyCharacterMap::Parser::~Parser() {
725 }
726 
parse()727 status_t KeyCharacterMap::Parser::parse() {
728     while (!mTokenizer->isEof()) {
729 #if DEBUG_PARSER
730         ALOGD("Parsing %s: '%s'.", mTokenizer->getLocation().string(),
731                 mTokenizer->peekRemainderOfLine().string());
732 #endif
733 
734         mTokenizer->skipDelimiters(WHITESPACE);
735 
736         if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
737             switch (mState) {
738             case STATE_TOP: {
739                 String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
740                 if (keywordToken == "type") {
741                     mTokenizer->skipDelimiters(WHITESPACE);
742                     status_t status = parseType();
743                     if (status) return status;
744                 } else if (keywordToken == "map") {
745                     mTokenizer->skipDelimiters(WHITESPACE);
746                     status_t status = parseMap();
747                     if (status) return status;
748                 } else if (keywordToken == "key") {
749                     mTokenizer->skipDelimiters(WHITESPACE);
750                     status_t status = parseKey();
751                     if (status) return status;
752                 } else {
753                     ALOGE("%s: Expected keyword, got '%s'.", mTokenizer->getLocation().string(),
754                             keywordToken.string());
755                     return BAD_VALUE;
756                 }
757                 break;
758             }
759 
760             case STATE_KEY: {
761                 status_t status = parseKeyProperty();
762                 if (status) return status;
763                 break;
764             }
765             }
766 
767             mTokenizer->skipDelimiters(WHITESPACE);
768             if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
769                 ALOGE("%s: Expected end of line or trailing comment, got '%s'.",
770                         mTokenizer->getLocation().string(),
771                         mTokenizer->peekRemainderOfLine().string());
772                 return BAD_VALUE;
773             }
774         }
775 
776         mTokenizer->nextLine();
777     }
778 
779     if (mState != STATE_TOP) {
780         ALOGE("%s: Unterminated key description at end of file.",
781                 mTokenizer->getLocation().string());
782         return BAD_VALUE;
783     }
784 
785     if (mMap->mType == KEYBOARD_TYPE_UNKNOWN) {
786         ALOGE("%s: Keyboard layout missing required keyboard 'type' declaration.",
787                 mTokenizer->getLocation().string());
788         return BAD_VALUE;
789     }
790 
791     if (mFormat == FORMAT_BASE) {
792         if (mMap->mType == KEYBOARD_TYPE_OVERLAY) {
793             ALOGE("%s: Base keyboard layout must specify a keyboard 'type' other than 'OVERLAY'.",
794                     mTokenizer->getLocation().string());
795             return BAD_VALUE;
796         }
797     } else if (mFormat == FORMAT_OVERLAY) {
798         if (mMap->mType != KEYBOARD_TYPE_OVERLAY) {
799             ALOGE("%s: Overlay keyboard layout missing required keyboard "
800                     "'type OVERLAY' declaration.",
801                     mTokenizer->getLocation().string());
802             return BAD_VALUE;
803         }
804     }
805 
806     return NO_ERROR;
807 }
808 
parseType()809 status_t KeyCharacterMap::Parser::parseType() {
810     if (mMap->mType != KEYBOARD_TYPE_UNKNOWN) {
811         ALOGE("%s: Duplicate keyboard 'type' declaration.",
812                 mTokenizer->getLocation().string());
813         return BAD_VALUE;
814     }
815 
816     KeyboardType type;
817     String8 typeToken = mTokenizer->nextToken(WHITESPACE);
818     if (typeToken == "NUMERIC") {
819         type = KEYBOARD_TYPE_NUMERIC;
820     } else if (typeToken == "PREDICTIVE") {
821         type = KEYBOARD_TYPE_PREDICTIVE;
822     } else if (typeToken == "ALPHA") {
823         type = KEYBOARD_TYPE_ALPHA;
824     } else if (typeToken == "FULL") {
825         type = KEYBOARD_TYPE_FULL;
826     } else if (typeToken == "SPECIAL_FUNCTION") {
827         ALOGW("The SPECIAL_FUNCTION type is now declared in the device's IDC file, please set "
828                 "the property 'keyboard.specialFunction' to '1' there instead.");
829         // TODO: return BAD_VALUE here in Q
830         type = KEYBOARD_TYPE_SPECIAL_FUNCTION;
831     } else if (typeToken == "OVERLAY") {
832         type = KEYBOARD_TYPE_OVERLAY;
833     } else {
834         ALOGE("%s: Expected keyboard type label, got '%s'.", mTokenizer->getLocation().string(),
835                 typeToken.string());
836         return BAD_VALUE;
837     }
838 
839 #if DEBUG_PARSER
840     ALOGD("Parsed type: type=%d.", type);
841 #endif
842     mMap->mType = type;
843     return NO_ERROR;
844 }
845 
parseMap()846 status_t KeyCharacterMap::Parser::parseMap() {
847     String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
848     if (keywordToken == "key") {
849         mTokenizer->skipDelimiters(WHITESPACE);
850         return parseMapKey();
851     }
852     ALOGE("%s: Expected keyword after 'map', got '%s'.", mTokenizer->getLocation().string(),
853             keywordToken.string());
854     return BAD_VALUE;
855 }
856 
parseMapKey()857 status_t KeyCharacterMap::Parser::parseMapKey() {
858     String8 codeToken = mTokenizer->nextToken(WHITESPACE);
859     bool mapUsage = false;
860     if (codeToken == "usage") {
861         mapUsage = true;
862         mTokenizer->skipDelimiters(WHITESPACE);
863         codeToken = mTokenizer->nextToken(WHITESPACE);
864     }
865 
866     char* end;
867     int32_t code = int32_t(strtol(codeToken.string(), &end, 0));
868     if (*end) {
869         ALOGE("%s: Expected key %s number, got '%s'.", mTokenizer->getLocation().string(),
870                 mapUsage ? "usage" : "scan code", codeToken.string());
871         return BAD_VALUE;
872     }
873     KeyedVector<int32_t, int32_t>& map =
874             mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;
875     if (map.indexOfKey(code) >= 0) {
876         ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),
877                 mapUsage ? "usage" : "scan code", codeToken.string());
878         return BAD_VALUE;
879     }
880 
881     mTokenizer->skipDelimiters(WHITESPACE);
882     String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
883     int32_t keyCode = getKeyCodeByLabel(keyCodeToken.string());
884     if (!keyCode) {
885         ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
886                 keyCodeToken.string());
887         return BAD_VALUE;
888     }
889 
890 #if DEBUG_PARSER
891     ALOGD("Parsed map key %s: code=%d, keyCode=%d.",
892             mapUsage ? "usage" : "scan code", code, keyCode);
893 #endif
894     map.add(code, keyCode);
895     return NO_ERROR;
896 }
897 
parseKey()898 status_t KeyCharacterMap::Parser::parseKey() {
899     String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
900     int32_t keyCode = getKeyCodeByLabel(keyCodeToken.string());
901     if (!keyCode) {
902         ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
903                 keyCodeToken.string());
904         return BAD_VALUE;
905     }
906     if (mMap->mKeys.indexOfKey(keyCode) >= 0) {
907         ALOGE("%s: Duplicate entry for key code '%s'.", mTokenizer->getLocation().string(),
908                 keyCodeToken.string());
909         return BAD_VALUE;
910     }
911 
912     mTokenizer->skipDelimiters(WHITESPACE);
913     String8 openBraceToken = mTokenizer->nextToken(WHITESPACE);
914     if (openBraceToken != "{") {
915         ALOGE("%s: Expected '{' after key code label, got '%s'.",
916                 mTokenizer->getLocation().string(), openBraceToken.string());
917         return BAD_VALUE;
918     }
919 
920 #if DEBUG_PARSER
921     ALOGD("Parsed beginning of key: keyCode=%d.", keyCode);
922 #endif
923     mKeyCode = keyCode;
924     mMap->mKeys.add(keyCode, new Key());
925     mState = STATE_KEY;
926     return NO_ERROR;
927 }
928 
parseKeyProperty()929 status_t KeyCharacterMap::Parser::parseKeyProperty() {
930     Key* key = mMap->mKeys.valueFor(mKeyCode);
931     String8 token = mTokenizer->nextToken(WHITESPACE_OR_PROPERTY_DELIMITER);
932     if (token == "}") {
933         mState = STATE_TOP;
934         return finishKey(key);
935     }
936 
937     Vector<Property> properties;
938 
939     // Parse all comma-delimited property names up to the first colon.
940     for (;;) {
941         if (token == "label") {
942             properties.add(Property(PROPERTY_LABEL));
943         } else if (token == "number") {
944             properties.add(Property(PROPERTY_NUMBER));
945         } else {
946             int32_t metaState;
947             status_t status = parseModifier(token.string(), &metaState);
948             if (status) {
949                 ALOGE("%s: Expected a property name or modifier, got '%s'.",
950                         mTokenizer->getLocation().string(), token.string());
951                 return status;
952             }
953             properties.add(Property(PROPERTY_META, metaState));
954         }
955 
956         mTokenizer->skipDelimiters(WHITESPACE);
957         if (!mTokenizer->isEol()) {
958             char ch = mTokenizer->nextChar();
959             if (ch == ':') {
960                 break;
961             } else if (ch == ',') {
962                 mTokenizer->skipDelimiters(WHITESPACE);
963                 token = mTokenizer->nextToken(WHITESPACE_OR_PROPERTY_DELIMITER);
964                 continue;
965             }
966         }
967 
968         ALOGE("%s: Expected ',' or ':' after property name.",
969                 mTokenizer->getLocation().string());
970         return BAD_VALUE;
971     }
972 
973     // Parse behavior after the colon.
974     mTokenizer->skipDelimiters(WHITESPACE);
975 
976     Behavior behavior;
977     bool haveCharacter = false;
978     bool haveFallback = false;
979     bool haveReplacement = false;
980 
981     do {
982         char ch = mTokenizer->peekChar();
983         if (ch == '\'') {
984             char16_t character;
985             status_t status = parseCharacterLiteral(&character);
986             if (status || !character) {
987                 ALOGE("%s: Invalid character literal for key.",
988                         mTokenizer->getLocation().string());
989                 return BAD_VALUE;
990             }
991             if (haveCharacter) {
992                 ALOGE("%s: Cannot combine multiple character literals or 'none'.",
993                         mTokenizer->getLocation().string());
994                 return BAD_VALUE;
995             }
996             if (haveReplacement) {
997                 ALOGE("%s: Cannot combine character literal with replace action.",
998                         mTokenizer->getLocation().string());
999                 return BAD_VALUE;
1000             }
1001             behavior.character = character;
1002             haveCharacter = true;
1003         } else {
1004             token = mTokenizer->nextToken(WHITESPACE);
1005             if (token == "none") {
1006                 if (haveCharacter) {
1007                     ALOGE("%s: Cannot combine multiple character literals or 'none'.",
1008                             mTokenizer->getLocation().string());
1009                     return BAD_VALUE;
1010                 }
1011                 if (haveReplacement) {
1012                     ALOGE("%s: Cannot combine 'none' with replace action.",
1013                             mTokenizer->getLocation().string());
1014                     return BAD_VALUE;
1015                 }
1016                 haveCharacter = true;
1017             } else if (token == "fallback") {
1018                 mTokenizer->skipDelimiters(WHITESPACE);
1019                 token = mTokenizer->nextToken(WHITESPACE);
1020                 int32_t keyCode = getKeyCodeByLabel(token.string());
1021                 if (!keyCode) {
1022                     ALOGE("%s: Invalid key code label for fallback behavior, got '%s'.",
1023                             mTokenizer->getLocation().string(),
1024                             token.string());
1025                     return BAD_VALUE;
1026                 }
1027                 if (haveFallback || haveReplacement) {
1028                     ALOGE("%s: Cannot combine multiple fallback/replacement key codes.",
1029                             mTokenizer->getLocation().string());
1030                     return BAD_VALUE;
1031                 }
1032                 behavior.fallbackKeyCode = keyCode;
1033                 haveFallback = true;
1034             } else if (token == "replace") {
1035                 mTokenizer->skipDelimiters(WHITESPACE);
1036                 token = mTokenizer->nextToken(WHITESPACE);
1037                 int32_t keyCode = getKeyCodeByLabel(token.string());
1038                 if (!keyCode) {
1039                     ALOGE("%s: Invalid key code label for replace, got '%s'.",
1040                             mTokenizer->getLocation().string(),
1041                             token.string());
1042                     return BAD_VALUE;
1043                 }
1044                 if (haveCharacter) {
1045                     ALOGE("%s: Cannot combine character literal with replace action.",
1046                             mTokenizer->getLocation().string());
1047                     return BAD_VALUE;
1048                 }
1049                 if (haveFallback || haveReplacement) {
1050                     ALOGE("%s: Cannot combine multiple fallback/replacement key codes.",
1051                             mTokenizer->getLocation().string());
1052                     return BAD_VALUE;
1053                 }
1054                 behavior.replacementKeyCode = keyCode;
1055                 haveReplacement = true;
1056 
1057             } else {
1058                 ALOGE("%s: Expected a key behavior after ':'.",
1059                         mTokenizer->getLocation().string());
1060                 return BAD_VALUE;
1061             }
1062         }
1063 
1064         mTokenizer->skipDelimiters(WHITESPACE);
1065     } while (!mTokenizer->isEol() && mTokenizer->peekChar() != '#');
1066 
1067     // Add the behavior.
1068     for (size_t i = 0; i < properties.size(); i++) {
1069         const Property& property = properties.itemAt(i);
1070         switch (property.property) {
1071         case PROPERTY_LABEL:
1072             if (key->label) {
1073                 ALOGE("%s: Duplicate label for key.",
1074                         mTokenizer->getLocation().string());
1075                 return BAD_VALUE;
1076             }
1077             key->label = behavior.character;
1078 #if DEBUG_PARSER
1079             ALOGD("Parsed key label: keyCode=%d, label=%d.", mKeyCode, key->label);
1080 #endif
1081             break;
1082         case PROPERTY_NUMBER:
1083             if (key->number) {
1084                 ALOGE("%s: Duplicate number for key.",
1085                         mTokenizer->getLocation().string());
1086                 return BAD_VALUE;
1087             }
1088             key->number = behavior.character;
1089 #if DEBUG_PARSER
1090             ALOGD("Parsed key number: keyCode=%d, number=%d.", mKeyCode, key->number);
1091 #endif
1092             break;
1093         case PROPERTY_META: {
1094             for (Behavior* b = key->firstBehavior; b; b = b->next) {
1095                 if (b->metaState == property.metaState) {
1096                     ALOGE("%s: Duplicate key behavior for modifier.",
1097                             mTokenizer->getLocation().string());
1098                     return BAD_VALUE;
1099                 }
1100             }
1101             Behavior* newBehavior = new Behavior(behavior);
1102             newBehavior->metaState = property.metaState;
1103             newBehavior->next = key->firstBehavior;
1104             key->firstBehavior = newBehavior;
1105 #if DEBUG_PARSER
1106             ALOGD("Parsed key meta: keyCode=%d, meta=0x%x, char=%d, fallback=%d replace=%d.",
1107                     mKeyCode,
1108                     newBehavior->metaState, newBehavior->character,
1109                     newBehavior->fallbackKeyCode, newBehavior->replacementKeyCode);
1110 #endif
1111             break;
1112         }
1113         }
1114     }
1115     return NO_ERROR;
1116 }
1117 
finishKey(Key * key)1118 status_t KeyCharacterMap::Parser::finishKey(Key* key) {
1119     // Fill in default number property.
1120     if (!key->number) {
1121         char16_t digit = 0;
1122         char16_t symbol = 0;
1123         for (Behavior* b = key->firstBehavior; b; b = b->next) {
1124             char16_t ch = b->character;
1125             if (ch) {
1126                 if (ch >= '0' && ch <= '9') {
1127                     digit = ch;
1128                 } else if (ch == '(' || ch == ')' || ch == '#' || ch == '*'
1129                         || ch == '-' || ch == '+' || ch == ',' || ch == '.'
1130                         || ch == '\'' || ch == ':' || ch == ';' || ch == '/') {
1131                     symbol = ch;
1132                 }
1133             }
1134         }
1135         key->number = digit ? digit : symbol;
1136     }
1137     return NO_ERROR;
1138 }
1139 
parseModifier(const std::string & token,int32_t * outMetaState)1140 status_t KeyCharacterMap::Parser::parseModifier(const std::string& token, int32_t* outMetaState) {
1141     if (token == "base") {
1142         *outMetaState = 0;
1143         return NO_ERROR;
1144     }
1145 
1146     int32_t combinedMeta = 0;
1147 
1148     const char* str = token.c_str();
1149     const char* start = str;
1150     for (const char* cur = str; ; cur++) {
1151         char ch = *cur;
1152         if (ch == '+' || ch == '\0') {
1153             size_t len = cur - start;
1154             int32_t metaState = 0;
1155             for (size_t i = 0; i < sizeof(modifiers) / sizeof(Modifier); i++) {
1156                 if (strlen(modifiers[i].label) == len
1157                         && strncmp(modifiers[i].label, start, len) == 0) {
1158                     metaState = modifiers[i].metaState;
1159                     break;
1160                 }
1161             }
1162             if (!metaState) {
1163                 return BAD_VALUE;
1164             }
1165             if (combinedMeta & metaState) {
1166                 ALOGE("%s: Duplicate modifier combination '%s'.",
1167                         mTokenizer->getLocation().string(), token.c_str());
1168                 return BAD_VALUE;
1169             }
1170 
1171             combinedMeta |= metaState;
1172             start = cur + 1;
1173 
1174             if (ch == '\0') {
1175                 break;
1176             }
1177         }
1178     }
1179     *outMetaState = combinedMeta;
1180     return NO_ERROR;
1181 }
1182 
parseCharacterLiteral(char16_t * outCharacter)1183 status_t KeyCharacterMap::Parser::parseCharacterLiteral(char16_t* outCharacter) {
1184     char ch = mTokenizer->nextChar();
1185     if (ch != '\'') {
1186         goto Error;
1187     }
1188 
1189     ch = mTokenizer->nextChar();
1190     if (ch == '\\') {
1191         // Escape sequence.
1192         ch = mTokenizer->nextChar();
1193         if (ch == 'n') {
1194             *outCharacter = '\n';
1195         } else if (ch == 't') {
1196             *outCharacter = '\t';
1197         } else if (ch == '\\') {
1198             *outCharacter = '\\';
1199         } else if (ch == '\'') {
1200             *outCharacter = '\'';
1201         } else if (ch == '"') {
1202             *outCharacter = '"';
1203         } else if (ch == 'u') {
1204             *outCharacter = 0;
1205             for (int i = 0; i < 4; i++) {
1206                 ch = mTokenizer->nextChar();
1207                 int digit;
1208                 if (ch >= '0' && ch <= '9') {
1209                     digit = ch - '0';
1210                 } else if (ch >= 'A' && ch <= 'F') {
1211                     digit = ch - 'A' + 10;
1212                 } else if (ch >= 'a' && ch <= 'f') {
1213                     digit = ch - 'a' + 10;
1214                 } else {
1215                     goto Error;
1216                 }
1217                 *outCharacter = (*outCharacter << 4) | digit;
1218             }
1219         } else {
1220             goto Error;
1221         }
1222     } else if (ch >= 32 && ch <= 126 && ch != '\'') {
1223         // ASCII literal character.
1224         *outCharacter = ch;
1225     } else {
1226         goto Error;
1227     }
1228 
1229     ch = mTokenizer->nextChar();
1230     if (ch != '\'') {
1231         goto Error;
1232     }
1233 
1234     // Ensure that we consumed the entire token.
1235     if (mTokenizer->nextToken(WHITESPACE).isEmpty()) {
1236         return NO_ERROR;
1237     }
1238 
1239 Error:
1240     ALOGE("%s: Malformed character literal.", mTokenizer->getLocation().string());
1241     return BAD_VALUE;
1242 }
1243 
1244 } // namespace android
1245