1267 lines
46 KiB
C++
1267 lines
46 KiB
C++
/*
|
|
* 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>
|
|
|
|
#ifdef __linux__
|
|
#include <binder/Parcel.h>
|
|
#endif
|
|
#include <android/keycodes.h>
|
|
#include <attestation/HmacKeyManager.h>
|
|
#include <input/InputEventLabels.h>
|
|
#include <input/KeyCharacterMap.h>
|
|
#include <input/Keyboard.h>
|
|
|
|
#include <gui/constants.h>
|
|
#include <utils/Errors.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/Timers.h>
|
|
#include <utils/Tokenizer.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(const std::string& filename) : mLoadFileName(filename) {}
|
|
|
|
base::Result<std::shared_ptr<KeyCharacterMap>> KeyCharacterMap::load(const std::string& filename,
|
|
Format format) {
|
|
Tokenizer* tokenizer;
|
|
status_t status = Tokenizer::open(String8(filename.c_str()), &tokenizer);
|
|
if (status) {
|
|
return Errorf("Error {} opening key character map file {}.", status, filename.c_str());
|
|
}
|
|
std::shared_ptr<KeyCharacterMap> map =
|
|
std::shared_ptr<KeyCharacterMap>(new KeyCharacterMap(filename));
|
|
if (!map.get()) {
|
|
ALOGE("Error allocating key character map.");
|
|
return Errorf("Error allocating key character map.");
|
|
}
|
|
std::unique_ptr<Tokenizer> t(tokenizer);
|
|
status = map->load(t.get(), format);
|
|
if (status == OK) {
|
|
return map;
|
|
}
|
|
return Errorf("Load KeyCharacterMap failed {}.", status);
|
|
}
|
|
|
|
base::Result<std::shared_ptr<KeyCharacterMap>> KeyCharacterMap::loadContents(
|
|
const std::string& filename, const char* contents, Format format) {
|
|
Tokenizer* tokenizer;
|
|
status_t status = Tokenizer::fromContents(String8(filename.c_str()), contents, &tokenizer);
|
|
if (status) {
|
|
ALOGE("Error %d opening key character map.", status);
|
|
return Errorf("Error {} opening key character map.", status);
|
|
}
|
|
std::shared_ptr<KeyCharacterMap> map =
|
|
std::shared_ptr<KeyCharacterMap>(new KeyCharacterMap(filename));
|
|
if (!map.get()) {
|
|
ALOGE("Error allocating key character map.");
|
|
return Errorf("Error allocating key character map.");
|
|
}
|
|
std::unique_ptr<Tokenizer> t(tokenizer);
|
|
status = map->load(t.get(), format);
|
|
if (status == OK) {
|
|
return map;
|
|
}
|
|
return Errorf("Load KeyCharacterMap failed {}.", status);
|
|
}
|
|
|
|
status_t KeyCharacterMap::load(Tokenizer* tokenizer, Format format) {
|
|
status_t status = OK;
|
|
#if DEBUG_PARSER_PERFORMANCE
|
|
nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
#endif
|
|
Parser parser(this, tokenizer, format);
|
|
status = parser.parse();
|
|
#if DEBUG_PARSER_PERFORMANCE
|
|
nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
|
|
ALOGD("Parsed key character map file '%s' %d lines in %0.3fms.",
|
|
tokenizer->getFilename().string(), tokenizer->getLineNumber(), elapsedTime / 1000000.0);
|
|
#endif
|
|
if (status != OK) {
|
|
ALOGE("Loading KeyCharacterMap failed with status %s", statusToString(status).c_str());
|
|
}
|
|
return status;
|
|
}
|
|
|
|
void KeyCharacterMap::clear() {
|
|
mKeysByScanCode.clear();
|
|
mKeysByUsageCode.clear();
|
|
mKeys.clear();
|
|
mLayoutOverlayApplied = false;
|
|
mType = KeyboardType::UNKNOWN;
|
|
}
|
|
|
|
status_t KeyCharacterMap::reloadBaseFromFile() {
|
|
clear();
|
|
Tokenizer* tokenizer;
|
|
status_t status = Tokenizer::open(String8(mLoadFileName.c_str()), &tokenizer);
|
|
if (status) {
|
|
ALOGE("Error %s opening key character map file %s.", statusToString(status).c_str(),
|
|
mLoadFileName.c_str());
|
|
return status;
|
|
}
|
|
std::unique_ptr<Tokenizer> t(tokenizer);
|
|
return load(t.get(), KeyCharacterMap::Format::BASE);
|
|
}
|
|
|
|
void KeyCharacterMap::combine(const KeyCharacterMap& overlay) {
|
|
if (mLayoutOverlayApplied) {
|
|
reloadBaseFromFile();
|
|
}
|
|
for (const auto& [keyCode, key] : overlay.mKeys) {
|
|
mKeys.insert_or_assign(keyCode, key);
|
|
}
|
|
|
|
for (const auto& [fromScanCode, toAndroidKeyCode] : overlay.mKeysByScanCode) {
|
|
mKeysByScanCode.insert_or_assign(fromScanCode, toAndroidKeyCode);
|
|
}
|
|
|
|
for (const auto& [fromHidUsageCode, toAndroidKeyCode] : overlay.mKeysByUsageCode) {
|
|
mKeysByUsageCode.insert_or_assign(fromHidUsageCode, toAndroidKeyCode);
|
|
}
|
|
mLayoutOverlayApplied = true;
|
|
}
|
|
|
|
void KeyCharacterMap::clearLayoutOverlay() {
|
|
if (mLayoutOverlayApplied) {
|
|
reloadBaseFromFile();
|
|
mLayoutOverlayApplied = false;
|
|
}
|
|
}
|
|
|
|
KeyCharacterMap::KeyboardType KeyCharacterMap::getKeyboardType() const {
|
|
return mType;
|
|
}
|
|
|
|
const std::string KeyCharacterMap::getLoadFileName() const {
|
|
return mLoadFileName;
|
|
}
|
|
|
|
char16_t KeyCharacterMap::getDisplayLabel(int32_t keyCode) const {
|
|
char16_t result = 0;
|
|
const Key* key = getKey(keyCode);
|
|
if (key != nullptr) {
|
|
result = key->label;
|
|
}
|
|
#if DEBUG_MAPPING
|
|
ALOGD("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 = getKey(keyCode);
|
|
if (key != nullptr) {
|
|
result = key->number;
|
|
}
|
|
#if DEBUG_MAPPING
|
|
ALOGD("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 Behavior* behavior = getKeyBehavior(keyCode, metaState);
|
|
if (behavior != nullptr) {
|
|
result = behavior->character;
|
|
}
|
|
#if DEBUG_MAPPING
|
|
ALOGD("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 Behavior* behavior = getKeyBehavior(keyCode, metaState);
|
|
if (behavior != nullptr) {
|
|
if (behavior->fallbackKeyCode) {
|
|
outFallbackAction->keyCode = behavior->fallbackKeyCode;
|
|
outFallbackAction->metaState = metaState & ~behavior->metaState;
|
|
result = true;
|
|
}
|
|
}
|
|
#if DEBUG_MAPPING
|
|
ALOGD("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 = getKey(keyCode);
|
|
if (key != nullptr) {
|
|
// 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->behaviors) {
|
|
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) {
|
|
// Found exact match!
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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
|
|
ALOGD("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
|
|
ALOGD("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++) {
|
|
ALOGD(" 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;
|
|
}
|
|
|
|
void KeyCharacterMap::addKeyRemapping(int32_t fromKeyCode, int32_t toKeyCode) {
|
|
if (fromKeyCode == toKeyCode) {
|
|
mKeyRemapping.erase(fromKeyCode);
|
|
#if DEBUG_MAPPING
|
|
ALOGD("addKeyRemapping: Cleared remapping forKeyCode=%d ~ Result Successful.", fromKeyCode);
|
|
#endif
|
|
return;
|
|
}
|
|
mKeyRemapping.insert_or_assign(fromKeyCode, toKeyCode);
|
|
#if DEBUG_MAPPING
|
|
ALOGD("addKeyRemapping: fromKeyCode=%d, toKeyCode=%d ~ Result Successful.", fromKeyCode,
|
|
toKeyCode);
|
|
#endif
|
|
}
|
|
|
|
status_t KeyCharacterMap::mapKey(int32_t scanCode, int32_t usageCode, int32_t* outKeyCode) const {
|
|
if (usageCode) {
|
|
const auto it = mKeysByUsageCode.find(usageCode);
|
|
if (it != mKeysByUsageCode.end()) {
|
|
*outKeyCode = it->second;
|
|
#if DEBUG_MAPPING
|
|
ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d.",
|
|
scanCode, usageCode, *outKeyCode);
|
|
#endif
|
|
return OK;
|
|
}
|
|
}
|
|
if (scanCode) {
|
|
const auto it = mKeysByScanCode.find(scanCode);
|
|
if (it != mKeysByScanCode.end()) {
|
|
*outKeyCode = it->second;
|
|
#if DEBUG_MAPPING
|
|
ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d.",
|
|
scanCode, usageCode, *outKeyCode);
|
|
#endif
|
|
return OK;
|
|
}
|
|
}
|
|
|
|
#if DEBUG_MAPPING
|
|
ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Failed.", scanCode, usageCode);
|
|
#endif
|
|
*outKeyCode = AKEYCODE_UNKNOWN;
|
|
return NAME_NOT_FOUND;
|
|
}
|
|
|
|
int32_t KeyCharacterMap::applyKeyRemapping(int32_t fromKeyCode) const {
|
|
int32_t toKeyCode = fromKeyCode;
|
|
|
|
const auto it = mKeyRemapping.find(fromKeyCode);
|
|
if (it != mKeyRemapping.end()) {
|
|
toKeyCode = it->second;
|
|
}
|
|
#if DEBUG_MAPPING
|
|
ALOGD("applyKeyRemapping: keyCode=%d ~ replacement keyCode=%d.", fromKeyCode, toKeyCode);
|
|
#endif
|
|
return toKeyCode;
|
|
}
|
|
|
|
std::pair<int32_t, int32_t> KeyCharacterMap::applyKeyBehavior(int32_t fromKeyCode,
|
|
int32_t fromMetaState) const {
|
|
int32_t toKeyCode = fromKeyCode;
|
|
int32_t toMetaState = fromMetaState;
|
|
|
|
const Behavior* behavior = getKeyBehavior(fromKeyCode, fromMetaState);
|
|
if (behavior != nullptr) {
|
|
if (behavior->replacementKeyCode) {
|
|
toKeyCode = behavior->replacementKeyCode;
|
|
toMetaState = fromMetaState & ~behavior->metaState;
|
|
// Reset dependent meta states.
|
|
if (behavior->metaState & AMETA_ALT_ON) {
|
|
toMetaState &= ~(AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON);
|
|
}
|
|
if (behavior->metaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
|
|
toMetaState &= ~AMETA_ALT_ON;
|
|
}
|
|
if (behavior->metaState & AMETA_CTRL_ON) {
|
|
toMetaState &= ~(AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON);
|
|
}
|
|
if (behavior->metaState & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
|
|
toMetaState &= ~AMETA_CTRL_ON;
|
|
}
|
|
if (behavior->metaState & AMETA_SHIFT_ON) {
|
|
toMetaState &= ~(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON);
|
|
}
|
|
if (behavior->metaState & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
|
|
toMetaState &= ~AMETA_SHIFT_ON;
|
|
}
|
|
// ... and put universal bits back if needed
|
|
toMetaState = normalizeMetaState(toMetaState);
|
|
}
|
|
}
|
|
|
|
#if DEBUG_MAPPING
|
|
ALOGD("applyKeyBehavior: keyCode=%d, metaState=0x%08x ~ "
|
|
"replacement keyCode=%d, replacement metaState=0x%08x.",
|
|
fromKeyCode, fromMetaState, toKeyCode, toMetaState);
|
|
#endif
|
|
return std::make_pair(toKeyCode, toMetaState);
|
|
}
|
|
|
|
const KeyCharacterMap::Key* KeyCharacterMap::getKey(int32_t keyCode) const {
|
|
auto it = mKeys.find(keyCode);
|
|
if (it != mKeys.end()) {
|
|
return &it->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const KeyCharacterMap::Behavior* KeyCharacterMap::getKeyBehavior(int32_t keyCode,
|
|
int32_t metaState) const {
|
|
const Key* key = getKey(keyCode);
|
|
if (key != nullptr) {
|
|
for (const Behavior& behavior : key->behaviors) {
|
|
if (matchesMetaState(metaState, behavior.metaState)) {
|
|
return &behavior;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool KeyCharacterMap::matchesMetaState(int32_t eventMetaState, int32_t behaviorMetaState) {
|
|
// Behavior must have at least the set of meta states specified.
|
|
// And if the key event has CTRL, ALT or META then the behavior must exactly
|
|
// match those, taking into account that a behavior can specify that it handles
|
|
// one, both or either of a left/right modifier pair.
|
|
if ((eventMetaState & behaviorMetaState) == behaviorMetaState) {
|
|
const int32_t EXACT_META_STATES =
|
|
AMETA_CTRL_ON | AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON
|
|
| AMETA_ALT_ON | AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON
|
|
| AMETA_META_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON;
|
|
int32_t unmatchedMetaState = eventMetaState & ~behaviorMetaState & EXACT_META_STATES;
|
|
if (behaviorMetaState & AMETA_CTRL_ON) {
|
|
unmatchedMetaState &= ~(AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON);
|
|
} else if (behaviorMetaState & (AMETA_CTRL_LEFT_ON | AMETA_CTRL_RIGHT_ON)) {
|
|
unmatchedMetaState &= ~AMETA_CTRL_ON;
|
|
}
|
|
if (behaviorMetaState & AMETA_ALT_ON) {
|
|
unmatchedMetaState &= ~(AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON);
|
|
} else if (behaviorMetaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
|
|
unmatchedMetaState &= ~AMETA_ALT_ON;
|
|
}
|
|
if (behaviorMetaState & AMETA_META_ON) {
|
|
unmatchedMetaState &= ~(AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
|
|
} else if (behaviorMetaState & (AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON)) {
|
|
unmatchedMetaState &= ~AMETA_META_ON;
|
|
}
|
|
return !unmatchedMetaState;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool KeyCharacterMap::findKey(char16_t ch, int32_t* outKeyCode, int32_t* outMetaState) const {
|
|
if (!ch) {
|
|
return false;
|
|
}
|
|
|
|
for (const auto& [keyCode, key] : mKeys) {
|
|
// 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 = nullptr;
|
|
for (const Behavior& behavior : key.behaviors) {
|
|
if (behavior.character == ch) {
|
|
found = &behavior;
|
|
}
|
|
}
|
|
if (found != nullptr) {
|
|
*outKeyCode = keyCode;
|
|
*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(InputEvent::nextId(), deviceId, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,
|
|
INVALID_HMAC, 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);
|
|
}
|
|
}
|
|
|
|
#ifdef __linux__
|
|
std::shared_ptr<KeyCharacterMap> KeyCharacterMap::readFromParcel(Parcel* parcel) {
|
|
if (parcel == nullptr) {
|
|
ALOGE("%s: Null parcel", __func__);
|
|
return nullptr;
|
|
}
|
|
std::string loadFileName = parcel->readCString();
|
|
std::shared_ptr<KeyCharacterMap> map =
|
|
std::shared_ptr<KeyCharacterMap>(new KeyCharacterMap(loadFileName));
|
|
map->mType = static_cast<KeyCharacterMap::KeyboardType>(parcel->readInt32());
|
|
map->mLayoutOverlayApplied = parcel->readBool();
|
|
size_t numKeys = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
if (numKeys > MAX_KEYS) {
|
|
ALOGE("Too many keys in KeyCharacterMap (%zu > %d)", numKeys, MAX_KEYS);
|
|
return nullptr;
|
|
}
|
|
|
|
for (size_t i = 0; i < numKeys; i++) {
|
|
int32_t keyCode = parcel->readInt32();
|
|
char16_t label = parcel->readInt32();
|
|
char16_t number = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
|
|
Key key{.label = label, .number = number};
|
|
while (parcel->readInt32()) {
|
|
int32_t metaState = parcel->readInt32();
|
|
char16_t character = parcel->readInt32();
|
|
int32_t fallbackKeyCode = parcel->readInt32();
|
|
int32_t replacementKeyCode = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
|
|
key.behaviors.push_back({
|
|
.metaState = metaState,
|
|
.character = character,
|
|
.fallbackKeyCode = fallbackKeyCode,
|
|
.replacementKeyCode = replacementKeyCode,
|
|
});
|
|
}
|
|
map->mKeys.emplace(keyCode, std::move(key));
|
|
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
size_t numKeyRemapping = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
for (size_t i = 0; i < numKeyRemapping; i++) {
|
|
int32_t key = parcel->readInt32();
|
|
int32_t value = parcel->readInt32();
|
|
map->mKeyRemapping.insert_or_assign(key, value);
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
size_t numKeysByScanCode = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
for (size_t i = 0; i < numKeysByScanCode; i++) {
|
|
int32_t key = parcel->readInt32();
|
|
int32_t value = parcel->readInt32();
|
|
map->mKeysByScanCode.insert_or_assign(key, value);
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
size_t numKeysByUsageCode = parcel->readInt32();
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
for (size_t i = 0; i < numKeysByUsageCode; i++) {
|
|
int32_t key = parcel->readInt32();
|
|
int32_t value = parcel->readInt32();
|
|
map->mKeysByUsageCode.insert_or_assign(key, value);
|
|
if (parcel->errorCheck()) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
void KeyCharacterMap::writeToParcel(Parcel* parcel) const {
|
|
if (parcel == nullptr) {
|
|
ALOGE("%s: Null parcel", __func__);
|
|
return;
|
|
}
|
|
parcel->writeCString(mLoadFileName.c_str());
|
|
parcel->writeInt32(static_cast<int32_t>(mType));
|
|
parcel->writeBool(mLayoutOverlayApplied);
|
|
|
|
size_t numKeys = mKeys.size();
|
|
parcel->writeInt32(numKeys);
|
|
for (const auto& [keyCode, key] : mKeys) {
|
|
parcel->writeInt32(keyCode);
|
|
parcel->writeInt32(key.label);
|
|
parcel->writeInt32(key.number);
|
|
for (const Behavior& behavior : key.behaviors) {
|
|
parcel->writeInt32(1);
|
|
parcel->writeInt32(behavior.metaState);
|
|
parcel->writeInt32(behavior.character);
|
|
parcel->writeInt32(behavior.fallbackKeyCode);
|
|
parcel->writeInt32(behavior.replacementKeyCode);
|
|
}
|
|
parcel->writeInt32(0);
|
|
}
|
|
size_t numKeyRemapping = mKeyRemapping.size();
|
|
parcel->writeInt32(numKeyRemapping);
|
|
for (auto const& [fromAndroidKeyCode, toAndroidKeyCode] : mKeyRemapping) {
|
|
parcel->writeInt32(fromAndroidKeyCode);
|
|
parcel->writeInt32(toAndroidKeyCode);
|
|
}
|
|
size_t numKeysByScanCode = mKeysByScanCode.size();
|
|
parcel->writeInt32(numKeysByScanCode);
|
|
for (auto const& [fromScanCode, toAndroidKeyCode] : mKeysByScanCode) {
|
|
parcel->writeInt32(fromScanCode);
|
|
parcel->writeInt32(toAndroidKeyCode);
|
|
}
|
|
size_t numKeysByUsageCode = mKeysByUsageCode.size();
|
|
parcel->writeInt32(numKeysByUsageCode);
|
|
for (auto const& [fromUsageCode, toAndroidKeyCode] : mKeysByUsageCode) {
|
|
parcel->writeInt32(fromUsageCode);
|
|
parcel->writeInt32(toAndroidKeyCode);
|
|
}
|
|
}
|
|
#endif // __linux__
|
|
|
|
// --- KeyCharacterMap::Parser ---
|
|
|
|
KeyCharacterMap::Parser::Parser(KeyCharacterMap* map, Tokenizer* tokenizer, Format format) :
|
|
mMap(map), mTokenizer(tokenizer), mFormat(format), mState(STATE_TOP) {
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parse() {
|
|
while (!mTokenizer->isEof()) {
|
|
#if DEBUG_PARSER
|
|
ALOGD("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 == "map") {
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
status_t status = parseMap();
|
|
if (status) return status;
|
|
} else if (keywordToken == "key") {
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
status_t status = parseKey();
|
|
if (status) return status;
|
|
} else {
|
|
ALOGE("%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() && mTokenizer->peekChar() != '#') {
|
|
ALOGE("%s: Expected end of line or trailing comment, got '%s'.",
|
|
mTokenizer->getLocation().string(),
|
|
mTokenizer->peekRemainderOfLine().string());
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
mTokenizer->nextLine();
|
|
}
|
|
|
|
if (mState != STATE_TOP) {
|
|
ALOGE("%s: Unterminated key description at end of file.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (mMap->mType == KeyboardType::UNKNOWN) {
|
|
ALOGE("%s: Keyboard layout missing required keyboard 'type' declaration.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (mFormat == Format::BASE) {
|
|
if (mMap->mType == KeyboardType::OVERLAY) {
|
|
ALOGE("%s: Base keyboard layout must specify a keyboard 'type' other than 'OVERLAY'.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
} else if (mFormat == Format::OVERLAY) {
|
|
if (mMap->mType != KeyboardType::OVERLAY) {
|
|
ALOGE("%s: Overlay keyboard layout missing required keyboard "
|
|
"'type OVERLAY' declaration.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseType() {
|
|
if (mMap->mType != KeyboardType::UNKNOWN) {
|
|
ALOGE("%s: Duplicate keyboard 'type' declaration.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
KeyboardType type;
|
|
String8 typeToken = mTokenizer->nextToken(WHITESPACE);
|
|
if (typeToken == "NUMERIC") {
|
|
type = KeyboardType::NUMERIC;
|
|
} else if (typeToken == "PREDICTIVE") {
|
|
type = KeyboardType::PREDICTIVE;
|
|
} else if (typeToken == "ALPHA") {
|
|
type = KeyboardType::ALPHA;
|
|
} else if (typeToken == "FULL") {
|
|
type = KeyboardType::FULL;
|
|
} else if (typeToken == "SPECIAL_FUNCTION") {
|
|
ALOGW("The SPECIAL_FUNCTION type is now declared in the device's IDC file, please set "
|
|
"the property 'keyboard.specialFunction' to '1' there instead.");
|
|
// TODO: return BAD_VALUE here in Q
|
|
type = KeyboardType::SPECIAL_FUNCTION;
|
|
} else if (typeToken == "OVERLAY") {
|
|
type = KeyboardType::OVERLAY;
|
|
} else {
|
|
ALOGE("%s: Expected keyboard type label, got '%s'.", mTokenizer->getLocation().string(),
|
|
typeToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
#if DEBUG_PARSER
|
|
ALOGD("Parsed type: type=%d.", type);
|
|
#endif
|
|
mMap->mType = type;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseMap() {
|
|
String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
|
|
if (keywordToken == "key") {
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
return parseMapKey();
|
|
}
|
|
ALOGE("%s: Expected keyword after 'map', got '%s'.", mTokenizer->getLocation().string(),
|
|
keywordToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseMapKey() {
|
|
String8 codeToken = mTokenizer->nextToken(WHITESPACE);
|
|
bool mapUsage = false;
|
|
if (codeToken == "usage") {
|
|
mapUsage = true;
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
codeToken = mTokenizer->nextToken(WHITESPACE);
|
|
}
|
|
|
|
char* end;
|
|
int32_t code = int32_t(strtol(codeToken.string(), &end, 0));
|
|
if (*end) {
|
|
ALOGE("%s: Expected key %s number, got '%s'.", mTokenizer->getLocation().string(),
|
|
mapUsage ? "usage" : "scan code", codeToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
std::map<int32_t, int32_t>& map = mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;
|
|
const auto it = map.find(code);
|
|
if (it != map.end()) {
|
|
ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),
|
|
mapUsage ? "usage" : "scan code", codeToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
|
|
std::optional<int> keyCode = InputEventLookup::getKeyCodeByLabel(keyCodeToken.string());
|
|
if (!keyCode) {
|
|
ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
|
|
keyCodeToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
#if DEBUG_PARSER
|
|
ALOGD("Parsed map key %s: code=%d, keyCode=%d.",
|
|
mapUsage ? "usage" : "scan code", code, keyCode);
|
|
#endif
|
|
map.insert_or_assign(code, *keyCode);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseKey() {
|
|
String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
|
|
std::optional<int> keyCode = InputEventLookup::getKeyCodeByLabel(keyCodeToken.string());
|
|
if (!keyCode) {
|
|
ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
|
|
keyCodeToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (mMap->mKeys.find(*keyCode) != mMap->mKeys.end()) {
|
|
ALOGE("%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 != "{") {
|
|
ALOGE("%s: Expected '{' after key code label, got '%s'.",
|
|
mTokenizer->getLocation().string(), openBraceToken.string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
ALOGD_IF(DEBUG_PARSER, "Parsed beginning of key: keyCode=%d.", *keyCode);
|
|
mKeyCode = *keyCode;
|
|
mMap->mKeys.emplace(*keyCode, Key{});
|
|
mState = STATE_KEY;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseKeyProperty() {
|
|
Key& key = mMap->mKeys[mKeyCode];
|
|
String8 token = mTokenizer->nextToken(WHITESPACE_OR_PROPERTY_DELIMITER);
|
|
if (token == "}") {
|
|
mState = STATE_TOP;
|
|
return finishKey(key);
|
|
}
|
|
|
|
std::vector<Property> properties;
|
|
|
|
// Parse all comma-delimited property names up to the first colon.
|
|
for (;;) {
|
|
if (token == "label") {
|
|
properties.emplace_back(PROPERTY_LABEL);
|
|
} else if (token == "number") {
|
|
properties.emplace_back(PROPERTY_NUMBER);
|
|
} else {
|
|
int32_t metaState;
|
|
status_t status = parseModifier(token.string(), &metaState);
|
|
if (status) {
|
|
ALOGE("%s: Expected a property name or modifier, got '%s'.",
|
|
mTokenizer->getLocation().string(), token.string());
|
|
return status;
|
|
}
|
|
properties.emplace_back(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;
|
|
}
|
|
}
|
|
|
|
ALOGE("%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;
|
|
bool haveReplacement = false;
|
|
|
|
do {
|
|
char ch = mTokenizer->peekChar();
|
|
if (ch == '\'') {
|
|
char16_t character;
|
|
status_t status = parseCharacterLiteral(&character);
|
|
if (status || !character) {
|
|
ALOGE("%s: Invalid character literal for key.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveCharacter) {
|
|
ALOGE("%s: Cannot combine multiple character literals or 'none'.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveReplacement) {
|
|
ALOGE("%s: Cannot combine character literal with replace action.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
behavior.character = character;
|
|
haveCharacter = true;
|
|
} else {
|
|
token = mTokenizer->nextToken(WHITESPACE);
|
|
if (token == "none") {
|
|
if (haveCharacter) {
|
|
ALOGE("%s: Cannot combine multiple character literals or 'none'.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveReplacement) {
|
|
ALOGE("%s: Cannot combine 'none' with replace action.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
haveCharacter = true;
|
|
} else if (token == "fallback") {
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
token = mTokenizer->nextToken(WHITESPACE);
|
|
std::optional<int> keyCode = InputEventLookup::getKeyCodeByLabel(token.string());
|
|
if (!keyCode) {
|
|
ALOGE("%s: Invalid key code label for fallback behavior, got '%s'.",
|
|
mTokenizer->getLocation().string(),
|
|
token.string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveFallback || haveReplacement) {
|
|
ALOGE("%s: Cannot combine multiple fallback/replacement key codes.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
behavior.fallbackKeyCode = *keyCode;
|
|
haveFallback = true;
|
|
} else if (token == "replace") {
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
token = mTokenizer->nextToken(WHITESPACE);
|
|
std::optional<int> keyCode = InputEventLookup::getKeyCodeByLabel(token.string());
|
|
if (!keyCode) {
|
|
ALOGE("%s: Invalid key code label for replace, got '%s'.",
|
|
mTokenizer->getLocation().string(),
|
|
token.string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveCharacter) {
|
|
ALOGE("%s: Cannot combine character literal with replace action.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
if (haveFallback || haveReplacement) {
|
|
ALOGE("%s: Cannot combine multiple fallback/replacement key codes.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
behavior.replacementKeyCode = *keyCode;
|
|
haveReplacement = true;
|
|
|
|
} else {
|
|
ALOGE("%s: Expected a key behavior after ':'.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
|
|
mTokenizer->skipDelimiters(WHITESPACE);
|
|
} while (!mTokenizer->isEol() && mTokenizer->peekChar() != '#');
|
|
|
|
// Add the behavior.
|
|
for (const Property& property : properties) {
|
|
switch (property.property) {
|
|
case PROPERTY_LABEL:
|
|
if (key.label) {
|
|
ALOGE("%s: Duplicate label for key.", mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
key.label = behavior.character;
|
|
#if DEBUG_PARSER
|
|
ALOGD("Parsed key label: keyCode=%d, label=%d.", mKeyCode, key.label);
|
|
#endif
|
|
break;
|
|
case PROPERTY_NUMBER:
|
|
if (key.number) {
|
|
ALOGE("%s: Duplicate number for key.", mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
key.number = behavior.character;
|
|
#if DEBUG_PARSER
|
|
ALOGD("Parsed key number: keyCode=%d, number=%d.", mKeyCode, key.number);
|
|
#endif
|
|
break;
|
|
case PROPERTY_META: {
|
|
for (const Behavior& b : key.behaviors) {
|
|
if (b.metaState == property.metaState) {
|
|
ALOGE("%s: Duplicate key behavior for modifier.",
|
|
mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
}
|
|
Behavior newBehavior = behavior;
|
|
newBehavior.metaState = property.metaState;
|
|
key.behaviors.push_front(newBehavior);
|
|
ALOGD_IF(DEBUG_PARSER,
|
|
"Parsed key meta: keyCode=%d, meta=0x%x, char=%d, fallback=%d replace=%d.",
|
|
mKeyCode, key.behaviors.front().metaState, key.behaviors.front().character,
|
|
key.behaviors.front().fallbackKeyCode,
|
|
key.behaviors.front().replacementKeyCode);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::finishKey(Key& key) {
|
|
// Fill in default number property.
|
|
if (!key.number) {
|
|
char16_t digit = 0;
|
|
char16_t symbol = 0;
|
|
for (const Behavior& b : key.behaviors) {
|
|
char16_t ch = b.character;
|
|
if (ch) {
|
|
if (ch >= '0' && ch <= '9') {
|
|
digit = ch;
|
|
} else if (ch == '(' || ch == ')' || ch == '#' || ch == '*'
|
|
|| ch == '-' || ch == '+' || ch == ',' || ch == '.'
|
|
|| ch == '\'' || ch == ':' || ch == ';' || ch == '/') {
|
|
symbol = ch;
|
|
}
|
|
}
|
|
}
|
|
key.number = digit ? digit : symbol;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t KeyCharacterMap::Parser::parseModifier(const std::string& token, int32_t* outMetaState) {
|
|
if (token == "base") {
|
|
*outMetaState = 0;
|
|
return NO_ERROR;
|
|
}
|
|
|
|
int32_t combinedMeta = 0;
|
|
|
|
const char* str = token.c_str();
|
|
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) {
|
|
ALOGE("%s: Duplicate modifier combination '%s'.",
|
|
mTokenizer->getLocation().string(), token.c_str());
|
|
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:
|
|
ALOGE("%s: Malformed character literal.", mTokenizer->getLocation().string());
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
} // namespace android
|