| /* | |
| * Copyright (C) 2008 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #define LOG_TAG "KeyCharacterMap" | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <android/keycodes.h> | |
| #include <ui/Keyboard.h> | |
| #include <ui/KeyCharacterMap.h> | |
| #include <utils/Log.h> | |
| #include <utils/Errors.h> | |
| #include <utils/Tokenizer.h> | |
| #include <utils/Timers.h> | |
| // Enables debug output for the parser. | |
| #define DEBUG_PARSER 0 | |
| // Enables debug output for parser performance. | |
| #define DEBUG_PARSER_PERFORMANCE 0 | |
| // Enables debug output for mapping. | |
| #define DEBUG_MAPPING 0 | |
| namespace android { | |
| static const char* WHITESPACE = " \t\r"; | |
| static const char* WHITESPACE_OR_PROPERTY_DELIMITER = " \t\r,:"; | |
| struct Modifier { | |
| const char* label; | |
| int32_t metaState; | |
| }; | |
| static const Modifier modifiers[] = { | |
| { "shift", AMETA_SHIFT_ON }, | |
| { "lshift", AMETA_SHIFT_LEFT_ON }, | |
| { "rshift", AMETA_SHIFT_RIGHT_ON }, | |
| { "alt", AMETA_ALT_ON }, | |
| { "lalt", AMETA_ALT_LEFT_ON }, | |
| { "ralt", AMETA_ALT_RIGHT_ON }, | |
| { "ctrl", AMETA_CTRL_ON }, | |
| { "lctrl", AMETA_CTRL_LEFT_ON }, | |
| { "rctrl", AMETA_CTRL_RIGHT_ON }, | |
| { "meta", AMETA_META_ON }, | |
| { "lmeta", AMETA_META_LEFT_ON }, | |
| { "rmeta", AMETA_META_RIGHT_ON }, | |
| { "sym", AMETA_SYM_ON }, | |
| { "fn", AMETA_FUNCTION_ON }, | |
| { "capslock", AMETA_CAPS_LOCK_ON }, | |
| { "numlock", AMETA_NUM_LOCK_ON }, | |
| { "scrolllock", AMETA_SCROLL_LOCK_ON }, | |
| }; | |
| #if DEBUG_MAPPING | |
| static String8 toString(const char16_t* chars, size_t numChars) { | |
| String8 result; | |
| for (size_t i = 0; i < numChars; i++) { | |
| result.appendFormat(i == 0 ? "%d" : ", %d", chars[i]); | |
| } | |
| return result; | |
| } | |
| #endif | |
| // --- KeyCharacterMap --- | |
| KeyCharacterMap::KeyCharacterMap() : | |
| mType(KEYBOARD_TYPE_UNKNOWN) { | |
| } | |
| KeyCharacterMap::~KeyCharacterMap() { | |
| for (size_t i = 0; i < mKeys.size(); i++) { | |
| Key* key = mKeys.editValueAt(i); | |
| delete key; | |
| } | |
| } | |
| status_t KeyCharacterMap::load(const String8& filename, KeyCharacterMap** outMap) { | |
| *outMap = NULL; | |
| Tokenizer* tokenizer; | |
| status_t status = Tokenizer::open(filename, &tokenizer); | |
| if (status) { | |
| LOGE("Error %d opening key character map file %s.", status, filename.string()); | |
| } else { | |
| KeyCharacterMap* map = new KeyCharacterMap(); | |
| if (!map) { | |
| LOGE("Error allocating key character map."); | |
| status = NO_MEMORY; | |
| } else { | |
| #if DEBUG_PARSER_PERFORMANCE | |
| nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC); | |
| #endif | |
| Parser parser(map, tokenizer); | |
| status = parser.parse(); | |
| #if DEBUG_PARSER_PERFORMANCE | |
| nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime; | |
| LOGD("Parsed key character map file '%s' %d lines in %0.3fms.", | |
| tokenizer->getFilename().string(), tokenizer->getLineNumber(), | |
| elapsedTime / 1000000.0); | |
| #endif | |
| if (status) { | |
| delete map; | |
| } else { | |
| *outMap = map; | |
| } | |
| } | |
| delete tokenizer; | |
| } | |
| return status; | |
| } | |
| status_t KeyCharacterMap::loadByDeviceId(int32_t deviceId, KeyCharacterMap** outMap) { | |
| *outMap = NULL; | |
| String8 filename; | |
| status_t result = getKeyCharacterMapFile(deviceId, filename); | |
| if (!result) { | |
| result = load(filename, outMap); | |
| } | |
| return result; | |
| } | |
| int32_t KeyCharacterMap::getKeyboardType() const { | |
| return mType; | |
| } | |
| char16_t KeyCharacterMap::getDisplayLabel(int32_t keyCode) const { | |
| char16_t result = 0; | |
| const Key* key; | |
| if (getKey(keyCode, &key)) { | |
| result = key->label; | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getDisplayLabel: keyCode=%d ~ Result %d.", keyCode, result); | |
| #endif | |
| return result; | |
| } | |
| char16_t KeyCharacterMap::getNumber(int32_t keyCode) const { | |
| char16_t result = 0; | |
| const Key* key; | |
| if (getKey(keyCode, &key)) { | |
| result = key->number; | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getNumber: keyCode=%d ~ Result %d.", keyCode, result); | |
| #endif | |
| return result; | |
| } | |
| char16_t KeyCharacterMap::getCharacter(int32_t keyCode, int32_t metaState) const { | |
| char16_t result = 0; | |
| const Key* key; | |
| const Behavior* behavior; | |
| if (getKeyBehavior(keyCode, metaState, &key, &behavior)) { | |
| result = behavior->character; | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getCharacter: keyCode=%d, metaState=0x%08x ~ Result %d.", keyCode, metaState, result); | |
| #endif | |
| return result; | |
| } | |
| bool KeyCharacterMap::getFallbackAction(int32_t keyCode, int32_t metaState, | |
| FallbackAction* outFallbackAction) const { | |
| outFallbackAction->keyCode = 0; | |
| outFallbackAction->metaState = 0; | |
| bool result = false; | |
| const Key* key; | |
| const Behavior* behavior; | |
| if (getKeyBehavior(keyCode, metaState, &key, &behavior)) { | |
| if (behavior->fallbackKeyCode) { | |
| outFallbackAction->keyCode = behavior->fallbackKeyCode; | |
| outFallbackAction->metaState = metaState & ~behavior->metaState; | |
| result = true; | |
| } | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getFallbackKeyCode: keyCode=%d, metaState=0x%08x ~ Result %s, " | |
| "fallback keyCode=%d, fallback metaState=0x%08x.", | |
| keyCode, metaState, result ? "true" : "false", | |
| outFallbackAction->keyCode, outFallbackAction->metaState); | |
| #endif | |
| return result; | |
| } | |
| char16_t KeyCharacterMap::getMatch(int32_t keyCode, const char16_t* chars, size_t numChars, | |
| int32_t metaState) const { | |
| char16_t result = 0; | |
| const Key* key; | |
| if (getKey(keyCode, &key)) { | |
| // Try to find the most general behavior that maps to this character. | |
| // For example, the base key behavior will usually be last in the list. | |
| // However, if we find a perfect meta state match for one behavior then use that one. | |
| for (const Behavior* behavior = key->firstBehavior; behavior; behavior = behavior->next) { | |
| if (behavior->character) { | |
| for (size_t i = 0; i < numChars; i++) { | |
| if (behavior->character == chars[i]) { | |
| result = behavior->character; | |
| if ((behavior->metaState & metaState) == behavior->metaState) { | |
| goto ExactMatch; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| ExactMatch: ; | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getMatch: keyCode=%d, chars=[%s], metaState=0x%08x ~ Result %d.", | |
| keyCode, toString(chars, numChars).string(), metaState, result); | |
| #endif | |
| return result; | |
| } | |
| bool KeyCharacterMap::getEvents(int32_t deviceId, const char16_t* chars, size_t numChars, | |
| Vector<KeyEvent>& outEvents) const { | |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); | |
| for (size_t i = 0; i < numChars; i++) { | |
| int32_t keyCode, metaState; | |
| char16_t ch = chars[i]; | |
| if (!findKey(ch, &keyCode, &metaState)) { | |
| #if DEBUG_MAPPING | |
| LOGD("getEvents: deviceId=%d, chars=[%s] ~ Failed to find mapping for character %d.", | |
| deviceId, toString(chars, numChars).string(), ch); | |
| #endif | |
| return false; | |
| } | |
| int32_t currentMetaState = 0; | |
| addMetaKeys(outEvents, deviceId, metaState, true, now, ¤tMetaState); | |
| addKey(outEvents, deviceId, keyCode, currentMetaState, true, now); | |
| addKey(outEvents, deviceId, keyCode, currentMetaState, false, now); | |
| addMetaKeys(outEvents, deviceId, metaState, false, now, ¤tMetaState); | |
| } | |
| #if DEBUG_MAPPING | |
| LOGD("getEvents: deviceId=%d, chars=[%s] ~ Generated %d events.", | |
| deviceId, toString(chars, numChars).string(), int32_t(outEvents.size())); | |
| for (size_t i = 0; i < outEvents.size(); i++) { | |
| LOGD(" Key: keyCode=%d, metaState=0x%08x, %s.", | |
| outEvents[i].getKeyCode(), outEvents[i].getMetaState(), | |
| outEvents[i].getAction() == AKEY_EVENT_ACTION_DOWN ? "down" : "up"); | |
| } | |
| #endif | |
| return true; | |
| } | |
| bool KeyCharacterMap::getKey(int32_t keyCode, const Key** outKey) const { | |
| ssize_t index = mKeys.indexOfKey(keyCode); | |
| if (index >= 0) { | |
| *outKey = mKeys.valueAt(index); | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool KeyCharacterMap::getKeyBehavior(int32_t keyCode, int32_t metaState, | |
| const Key** outKey, const Behavior** outBehavior) const { | |
| const Key* key; | |
| if (getKey(keyCode, &key)) { | |
| const Behavior* behavior = key->firstBehavior; | |
| while (behavior) { | |
| if ((behavior->metaState & metaState) == behavior->metaState) { | |
| *outKey = key; | |
| *outBehavior = behavior; | |
| return true; | |
| } | |
| behavior = behavior->next; | |
| } | |
| } | |
| return false; | |
| } | |
| bool KeyCharacterMap::findKey(char16_t ch, int32_t* outKeyCode, int32_t* outMetaState) const { | |
| if (!ch) { | |
| return false; | |
| } | |
| for (size_t i = 0; i < mKeys.size(); i++) { | |
| const Key* key = mKeys.valueAt(i); | |
| // Try to find the most general behavior that maps to this character. | |
| // For example, the base key behavior will usually be last in the list. | |
| const Behavior* found = NULL; | |
| for (const Behavior* behavior = key->firstBehavior; behavior; behavior = behavior->next) { | |
| if (behavior->character == ch) { | |
| found = behavior; | |
| } | |
| } | |
| if (found) { | |
| *outKeyCode = mKeys.keyAt(i); | |
| *outMetaState = found->metaState; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| void KeyCharacterMap::addKey(Vector<KeyEvent>& outEvents, | |
| int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time) { | |
| outEvents.push(); | |
| KeyEvent& event = outEvents.editTop(); | |
| event.initialize(deviceId, AINPUT_SOURCE_KEYBOARD, | |
| down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, | |
| 0, keyCode, 0, metaState, 0, time, time); | |
| } | |
| void KeyCharacterMap::addMetaKeys(Vector<KeyEvent>& outEvents, | |
| int32_t deviceId, int32_t metaState, bool down, nsecs_t time, | |
| int32_t* currentMetaState) { | |
| // Add and remove meta keys symmetrically. | |
| if (down) { | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_CAPS_LOCK, AMETA_CAPS_LOCK_ON, currentMetaState); | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_NUM_LOCK, AMETA_NUM_LOCK_ON, currentMetaState); | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_SCROLL_LOCK, AMETA_SCROLL_LOCK_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_SHIFT_LEFT, AMETA_SHIFT_LEFT_ON, | |
| AKEYCODE_SHIFT_RIGHT, AMETA_SHIFT_RIGHT_ON, | |
| AMETA_SHIFT_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_ALT_LEFT, AMETA_ALT_LEFT_ON, | |
| AKEYCODE_ALT_RIGHT, AMETA_ALT_RIGHT_ON, | |
| AMETA_ALT_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_CTRL_LEFT, AMETA_CTRL_LEFT_ON, | |
| AKEYCODE_CTRL_RIGHT, AMETA_CTRL_RIGHT_ON, | |
| AMETA_CTRL_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_META_LEFT, AMETA_META_LEFT_ON, | |
| AKEYCODE_META_RIGHT, AMETA_META_RIGHT_ON, | |
| AMETA_META_ON, currentMetaState); | |
| addSingleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_SYM, AMETA_SYM_ON, currentMetaState); | |
| addSingleEphemeralMetaKey(outEvents, deviceId, metaState, true, time, | |
| AKEYCODE_FUNCTION, AMETA_FUNCTION_ON, currentMetaState); | |
| } else { | |
| addSingleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_FUNCTION, AMETA_FUNCTION_ON, currentMetaState); | |
| addSingleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_SYM, AMETA_SYM_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_META_LEFT, AMETA_META_LEFT_ON, | |
| AKEYCODE_META_RIGHT, AMETA_META_RIGHT_ON, | |
| AMETA_META_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_CTRL_LEFT, AMETA_CTRL_LEFT_ON, | |
| AKEYCODE_CTRL_RIGHT, AMETA_CTRL_RIGHT_ON, | |
| AMETA_CTRL_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_ALT_LEFT, AMETA_ALT_LEFT_ON, | |
| AKEYCODE_ALT_RIGHT, AMETA_ALT_RIGHT_ON, | |
| AMETA_ALT_ON, currentMetaState); | |
| addDoubleEphemeralMetaKey(outEvents, deviceId, metaState, false, time, | |
| AKEYCODE_SHIFT_LEFT, AMETA_SHIFT_LEFT_ON, | |
| AKEYCODE_SHIFT_RIGHT, AMETA_SHIFT_RIGHT_ON, | |
| AMETA_SHIFT_ON, currentMetaState); | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_SCROLL_LOCK, AMETA_SCROLL_LOCK_ON, currentMetaState); | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_NUM_LOCK, AMETA_NUM_LOCK_ON, currentMetaState); | |
| addLockedMetaKey(outEvents, deviceId, metaState, time, | |
| AKEYCODE_CAPS_LOCK, AMETA_CAPS_LOCK_ON, currentMetaState); | |
| } | |
| } | |
| bool KeyCharacterMap::addSingleEphemeralMetaKey(Vector<KeyEvent>& outEvents, | |
| int32_t deviceId, int32_t metaState, bool down, nsecs_t time, | |
| int32_t keyCode, int32_t keyMetaState, | |
| int32_t* currentMetaState) { | |
| if ((metaState & keyMetaState) == keyMetaState) { | |
| *currentMetaState = updateMetaState(keyCode, down, *currentMetaState); | |
| addKey(outEvents, deviceId, keyCode, *currentMetaState, down, time); | |
| return true; | |
| } | |
| return false; | |
| } | |
| void KeyCharacterMap::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) { | |
| bool specific = false; | |
| specific |= addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time, | |
| leftKeyCode, leftKeyMetaState, currentMetaState); | |
| specific |= addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time, | |
| rightKeyCode, rightKeyMetaState, currentMetaState); | |
| if (!specific) { | |
| addSingleEphemeralMetaKey(outEvents, deviceId, metaState, down, time, | |
| leftKeyCode, eitherKeyMetaState, currentMetaState); | |
| } | |
| } | |
| void KeyCharacterMap::addLockedMetaKey(Vector<KeyEvent>& outEvents, | |
| int32_t deviceId, int32_t metaState, nsecs_t time, | |
| int32_t keyCode, int32_t keyMetaState, | |
| int32_t* currentMetaState) { | |
| if ((metaState & keyMetaState) == keyMetaState) { | |
| *currentMetaState = updateMetaState(keyCode, true, *currentMetaState); | |
| addKey(outEvents, deviceId, keyCode, *currentMetaState, true, time); | |
| *currentMetaState = updateMetaState(keyCode, false, *currentMetaState); | |
| addKey(outEvents, deviceId, keyCode, *currentMetaState, false, time); | |
| } | |
| } | |
| // --- KeyCharacterMap::Key --- | |
| KeyCharacterMap::Key::Key() : | |
| label(0), number(0), firstBehavior(NULL) { | |
| } | |
| KeyCharacterMap::Key::~Key() { | |
| Behavior* behavior = firstBehavior; | |
| while (behavior) { | |
| Behavior* next = behavior->next; | |
| delete behavior; | |
| behavior = next; | |
| } | |
| } | |
| // --- KeyCharacterMap::Behavior --- | |
| KeyCharacterMap::Behavior::Behavior() : | |
| next(NULL), metaState(0), character(0), fallbackKeyCode(0) { | |
| } | |
| // --- KeyCharacterMap::Parser --- | |
| KeyCharacterMap::Parser::Parser(KeyCharacterMap* map, Tokenizer* tokenizer) : | |
| mMap(map), mTokenizer(tokenizer), mState(STATE_TOP) { | |
| } | |
| KeyCharacterMap::Parser::~Parser() { | |
| } | |
| status_t KeyCharacterMap::Parser::parse() { | |
| while (!mTokenizer->isEof()) { | |
| #if DEBUG_PARSER | |
| LOGD("Parsing %s: '%s'.", mTokenizer->getLocation().string(), | |
| mTokenizer->peekRemainderOfLine().string()); | |
| #endif | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') { | |
| switch (mState) { | |
| case STATE_TOP: { | |
| String8 keywordToken = mTokenizer->nextToken(WHITESPACE); | |
| if (keywordToken == "type") { | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| status_t status = parseType(); | |
| if (status) return status; | |
| } else if (keywordToken == "key") { | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| status_t status = parseKey(); | |
| if (status) return status; | |
| } else { | |
| LOGE("%s: Expected keyword, got '%s'.", mTokenizer->getLocation().string(), | |
| keywordToken.string()); | |
| return BAD_VALUE; | |
| } | |
| break; | |
| } | |
| case STATE_KEY: { | |
| status_t status = parseKeyProperty(); | |
| if (status) return status; | |
| break; | |
| } | |
| } | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| if (!mTokenizer->isEol()) { | |
| LOGE("%s: Expected end of line, got '%s'.", | |
| mTokenizer->getLocation().string(), | |
| mTokenizer->peekRemainderOfLine().string()); | |
| return BAD_VALUE; | |
| } | |
| } | |
| mTokenizer->nextLine(); | |
| } | |
| if (mState != STATE_TOP) { | |
| LOGE("%s: Unterminated key description at end of file.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| if (mMap->mType == KEYBOARD_TYPE_UNKNOWN) { | |
| LOGE("%s: Missing required keyboard 'type' declaration.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| return NO_ERROR; | |
| } | |
| status_t KeyCharacterMap::Parser::parseType() { | |
| if (mMap->mType != KEYBOARD_TYPE_UNKNOWN) { | |
| LOGE("%s: Duplicate keyboard 'type' declaration.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| KeyboardType type; | |
| String8 typeToken = mTokenizer->nextToken(WHITESPACE); | |
| if (typeToken == "NUMERIC") { | |
| type = KEYBOARD_TYPE_NUMERIC; | |
| } else if (typeToken == "PREDICTIVE") { | |
| type = KEYBOARD_TYPE_PREDICTIVE; | |
| } else if (typeToken == "ALPHA") { | |
| type = KEYBOARD_TYPE_ALPHA; | |
| } else if (typeToken == "FULL") { | |
| type = KEYBOARD_TYPE_FULL; | |
| } else if (typeToken == "SPECIAL_FUNCTION") { | |
| type = KEYBOARD_TYPE_SPECIAL_FUNCTION; | |
| } else { | |
| LOGE("%s: Expected keyboard type label, got '%s'.", mTokenizer->getLocation().string(), | |
| typeToken.string()); | |
| return BAD_VALUE; | |
| } | |
| #if DEBUG_PARSER | |
| LOGD("Parsed type: type=%d.", type); | |
| #endif | |
| mMap->mType = type; | |
| return NO_ERROR; | |
| } | |
| status_t KeyCharacterMap::Parser::parseKey() { | |
| String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE); | |
| int32_t keyCode = getKeyCodeByLabel(keyCodeToken.string()); | |
| if (!keyCode) { | |
| LOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(), | |
| keyCodeToken.string()); | |
| return BAD_VALUE; | |
| } | |
| if (mMap->mKeys.indexOfKey(keyCode) >= 0) { | |
| LOGE("%s: Duplicate entry for key code '%s'.", mTokenizer->getLocation().string(), | |
| keyCodeToken.string()); | |
| return BAD_VALUE; | |
| } | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| String8 openBraceToken = mTokenizer->nextToken(WHITESPACE); | |
| if (openBraceToken != "{") { | |
| LOGE("%s: Expected '{' after key code label, got '%s'.", | |
| mTokenizer->getLocation().string(), openBraceToken.string()); | |
| return BAD_VALUE; | |
| } | |
| #if DEBUG_PARSER | |
| LOGD("Parsed beginning of key: keyCode=%d.", keyCode); | |
| #endif | |
| mKeyCode = keyCode; | |
| mMap->mKeys.add(keyCode, new Key()); | |
| mState = STATE_KEY; | |
| return NO_ERROR; | |
| } | |
| status_t KeyCharacterMap::Parser::parseKeyProperty() { | |
| String8 token = mTokenizer->nextToken(WHITESPACE_OR_PROPERTY_DELIMITER); | |
| if (token == "}") { | |
| mState = STATE_TOP; | |
| return NO_ERROR; | |
| } | |
| Vector<Property> properties; | |
| // Parse all comma-delimited property names up to the first colon. | |
| for (;;) { | |
| if (token == "label") { | |
| properties.add(Property(PROPERTY_LABEL)); | |
| } else if (token == "number") { | |
| properties.add(Property(PROPERTY_NUMBER)); | |
| } else { | |
| int32_t metaState; | |
| status_t status = parseModifier(token, &metaState); | |
| if (status) { | |
| LOGE("%s: Expected a property name or modifier, got '%s'.", | |
| mTokenizer->getLocation().string(), token.string()); | |
| return status; | |
| } | |
| properties.add(Property(PROPERTY_META, metaState)); | |
| } | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| if (!mTokenizer->isEol()) { | |
| char ch = mTokenizer->nextChar(); | |
| if (ch == ':') { | |
| break; | |
| } else if (ch == ',') { | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| token = mTokenizer->nextToken(WHITESPACE_OR_PROPERTY_DELIMITER); | |
| continue; | |
| } | |
| } | |
| LOGE("%s: Expected ',' or ':' after property name.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| // Parse behavior after the colon. | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| Behavior behavior; | |
| bool haveCharacter = false; | |
| bool haveFallback = false; | |
| do { | |
| char ch = mTokenizer->peekChar(); | |
| if (ch == '\'') { | |
| char16_t character; | |
| status_t status = parseCharacterLiteral(&character); | |
| if (status || !character) { | |
| LOGE("%s: Invalid character literal for key.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| if (haveCharacter) { | |
| LOGE("%s: Cannot combine multiple character literals or 'none'.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| behavior.character = character; | |
| haveCharacter = true; | |
| } else { | |
| token = mTokenizer->nextToken(WHITESPACE); | |
| if (token == "none") { | |
| if (haveCharacter) { | |
| LOGE("%s: Cannot combine multiple character literals or 'none'.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| haveCharacter = true; | |
| } else if (token == "fallback") { | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| token = mTokenizer->nextToken(WHITESPACE); | |
| int32_t keyCode = getKeyCodeByLabel(token.string()); | |
| if (!keyCode) { | |
| LOGE("%s: Invalid key code label for fallback behavior, got '%s'.", | |
| mTokenizer->getLocation().string(), | |
| token.string()); | |
| return BAD_VALUE; | |
| } | |
| if (haveFallback) { | |
| LOGE("%s: Cannot combine multiple fallback key codes.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| behavior.fallbackKeyCode = keyCode; | |
| haveFallback = true; | |
| } else { | |
| LOGE("%s: Expected a key behavior after ':'.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| } | |
| mTokenizer->skipDelimiters(WHITESPACE); | |
| } while (!mTokenizer->isEol()); | |
| // Add the behavior. | |
| Key* key = mMap->mKeys.valueFor(mKeyCode); | |
| for (size_t i = 0; i < properties.size(); i++) { | |
| const Property& property = properties.itemAt(i); | |
| switch (property.property) { | |
| case PROPERTY_LABEL: | |
| if (key->label) { | |
| LOGE("%s: Duplicate label for key.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| key->label = behavior.character; | |
| #if DEBUG_PARSER | |
| LOGD("Parsed key label: keyCode=%d, label=%d.", mKeyCode, key->label); | |
| #endif | |
| break; | |
| case PROPERTY_NUMBER: | |
| if (key->number) { | |
| LOGE("%s: Duplicate number for key.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| key->number = behavior.character; | |
| #if DEBUG_PARSER | |
| LOGD("Parsed key number: keyCode=%d, number=%d.", mKeyCode, key->number); | |
| #endif | |
| break; | |
| case PROPERTY_META: { | |
| for (Behavior* b = key->firstBehavior; b; b = b->next) { | |
| if (b->metaState == property.metaState) { | |
| LOGE("%s: Duplicate key behavior for modifier.", | |
| mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| } | |
| Behavior* newBehavior = new Behavior(behavior); | |
| newBehavior->metaState = property.metaState; | |
| newBehavior->next = key->firstBehavior; | |
| key->firstBehavior = newBehavior; | |
| #if DEBUG_PARSER | |
| LOGD("Parsed key meta: keyCode=%d, meta=0x%x, char=%d, fallback=%d.", mKeyCode, | |
| newBehavior->metaState, newBehavior->character, newBehavior->fallbackKeyCode); | |
| #endif | |
| break; | |
| } | |
| } | |
| } | |
| return NO_ERROR; | |
| } | |
| status_t KeyCharacterMap::Parser::parseModifier(const String8& token, int32_t* outMetaState) { | |
| if (token == "base") { | |
| *outMetaState = 0; | |
| return NO_ERROR; | |
| } | |
| int32_t combinedMeta = 0; | |
| const char* str = token.string(); | |
| const char* start = str; | |
| for (const char* cur = str; ; cur++) { | |
| char ch = *cur; | |
| if (ch == '+' || ch == '\0') { | |
| size_t len = cur - start; | |
| int32_t metaState = 0; | |
| for (size_t i = 0; i < sizeof(modifiers) / sizeof(Modifier); i++) { | |
| if (strlen(modifiers[i].label) == len | |
| && strncmp(modifiers[i].label, start, len) == 0) { | |
| metaState = modifiers[i].metaState; | |
| break; | |
| } | |
| } | |
| if (!metaState) { | |
| return BAD_VALUE; | |
| } | |
| if (combinedMeta & metaState) { | |
| LOGE("%s: Duplicate modifier combination '%s'.", | |
| mTokenizer->getLocation().string(), token.string()); | |
| return BAD_VALUE; | |
| } | |
| combinedMeta |= metaState; | |
| start = cur + 1; | |
| if (ch == '\0') { | |
| break; | |
| } | |
| } | |
| } | |
| *outMetaState = combinedMeta; | |
| return NO_ERROR; | |
| } | |
| status_t KeyCharacterMap::Parser::parseCharacterLiteral(char16_t* outCharacter) { | |
| char ch = mTokenizer->nextChar(); | |
| if (ch != '\'') { | |
| goto Error; | |
| } | |
| ch = mTokenizer->nextChar(); | |
| if (ch == '\\') { | |
| // Escape sequence. | |
| ch = mTokenizer->nextChar(); | |
| if (ch == 'n') { | |
| *outCharacter = '\n'; | |
| } else if (ch == 't') { | |
| *outCharacter = '\t'; | |
| } else if (ch == '\\') { | |
| *outCharacter = '\\'; | |
| } else if (ch == '\'') { | |
| *outCharacter = '\''; | |
| } else if (ch == '"') { | |
| *outCharacter = '"'; | |
| } else if (ch == 'u') { | |
| *outCharacter = 0; | |
| for (int i = 0; i < 4; i++) { | |
| ch = mTokenizer->nextChar(); | |
| int digit; | |
| if (ch >= '0' && ch <= '9') { | |
| digit = ch - '0'; | |
| } else if (ch >= 'A' && ch <= 'F') { | |
| digit = ch - 'A' + 10; | |
| } else if (ch >= 'a' && ch <= 'f') { | |
| digit = ch - 'a' + 10; | |
| } else { | |
| goto Error; | |
| } | |
| *outCharacter = (*outCharacter << 4) | digit; | |
| } | |
| } else { | |
| goto Error; | |
| } | |
| } else if (ch >= 32 && ch <= 126 && ch != '\'') { | |
| // ASCII literal character. | |
| *outCharacter = ch; | |
| } else { | |
| goto Error; | |
| } | |
| ch = mTokenizer->nextChar(); | |
| if (ch != '\'') { | |
| goto Error; | |
| } | |
| // Ensure that we consumed the entire token. | |
| if (mTokenizer->nextToken(WHITESPACE).isEmpty()) { | |
| return NO_ERROR; | |
| } | |
| Error: | |
| LOGE("%s: Malformed character literal.", mTokenizer->getLocation().string()); | |
| return BAD_VALUE; | |
| } | |
| } // namespace android |