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 "KeyLayoutMap"
18
19 #include <android-base/logging.h>
20 #include <android/keycodes.h>
21 #include <ftl/enum.h>
22 #include <input/InputEventLabels.h>
23 #include <input/KeyLayoutMap.h>
24 #include <input/Keyboard.h>
25 #include <log/log.h>
26 #include <utils/Errors.h>
27 #include <utils/Timers.h>
28 #include <utils/Tokenizer.h>
29 #if defined(__ANDROID__)
30 #include <vintf/RuntimeInfo.h>
31 #include <vintf/VintfObject.h>
32 #endif
33
34 #include <cstdlib>
35 #include <string_view>
36 #include <unordered_map>
37
38 /**
39 * Log debug output for the parser.
40 * Enable this via "adb shell setprop log.tag.KeyLayoutMapParser DEBUG" (requires restart)
41 */
42 const bool DEBUG_PARSER =
43 __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Parser", ANDROID_LOG_INFO);
44
45 // Enables debug output for parser performance.
46 #define DEBUG_PARSER_PERFORMANCE 0
47
48 /**
49 * Log debug output for mapping.
50 * Enable this via "adb shell setprop log.tag.KeyLayoutMapMapping DEBUG" (requires restart)
51 */
52 const bool DEBUG_MAPPING =
53 __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Mapping", ANDROID_LOG_INFO);
54
55 namespace android {
56 namespace {
57
parseInt(const char * str)58 std::optional<int> parseInt(const char* str) {
59 char* end;
60 errno = 0;
61 const int value = strtol(str, &end, 0);
62 if (end == str) {
63 LOG(ERROR) << "Could not parse " << str;
64 return {};
65 }
66 if (errno == ERANGE) {
67 LOG(ERROR) << "Out of bounds: " << str;
68 return {};
69 }
70 return value;
71 }
72
73 constexpr const char* WHITESPACE = " \t\r";
74
75 template <InputDeviceSensorType S>
sensorPair()76 constexpr auto sensorPair() {
77 return std::make_pair(ftl::enum_name<S>(), S);
78 }
79
80 static const std::unordered_map<std::string_view, InputDeviceSensorType> SENSOR_LIST =
81 {sensorPair<InputDeviceSensorType::ACCELEROMETER>(),
82 sensorPair<InputDeviceSensorType::MAGNETIC_FIELD>(),
83 sensorPair<InputDeviceSensorType::ORIENTATION>(),
84 sensorPair<InputDeviceSensorType::GYROSCOPE>(),
85 sensorPair<InputDeviceSensorType::LIGHT>(),
86 sensorPair<InputDeviceSensorType::PRESSURE>(),
87 sensorPair<InputDeviceSensorType::TEMPERATURE>(),
88 sensorPair<InputDeviceSensorType::PROXIMITY>(),
89 sensorPair<InputDeviceSensorType::GRAVITY>(),
90 sensorPair<InputDeviceSensorType::LINEAR_ACCELERATION>(),
91 sensorPair<InputDeviceSensorType::ROTATION_VECTOR>(),
92 sensorPair<InputDeviceSensorType::RELATIVE_HUMIDITY>(),
93 sensorPair<InputDeviceSensorType::AMBIENT_TEMPERATURE>(),
94 sensorPair<InputDeviceSensorType::MAGNETIC_FIELD_UNCALIBRATED>(),
95 sensorPair<InputDeviceSensorType::GAME_ROTATION_VECTOR>(),
96 sensorPair<InputDeviceSensorType::GYROSCOPE_UNCALIBRATED>(),
97 sensorPair<InputDeviceSensorType::SIGNIFICANT_MOTION>()};
98
kernelConfigsArePresent(const std::set<std::string> & configs)99 bool kernelConfigsArePresent(const std::set<std::string>& configs) {
100 #if defined(__ANDROID__)
101 std::shared_ptr<const android::vintf::RuntimeInfo> runtimeInfo =
102 android::vintf::VintfObject::GetInstance()->getRuntimeInfo(
103 vintf::RuntimeInfo::FetchFlag::CONFIG_GZ);
104 LOG_ALWAYS_FATAL_IF(runtimeInfo == nullptr, "Kernel configs could not be fetched");
105
106 const std::map<std::string, std::string>& kernelConfigs = runtimeInfo->kernelConfigs();
107 for (const std::string& requiredConfig : configs) {
108 const auto configIt = kernelConfigs.find(requiredConfig);
109 if (configIt == kernelConfigs.end()) {
110 ALOGI("Required kernel config %s is not found", requiredConfig.c_str());
111 return false;
112 }
113 const std::string& option = configIt->second;
114 if (option != "y" && option != "m") {
115 ALOGI("Required kernel config %s has option %s", requiredConfig.c_str(),
116 option.c_str());
117 return false;
118 }
119 }
120 return true;
121 #else
122 (void)configs; // Suppress 'unused variable' warning
123 return true;
124 #endif
125 }
126
127 } // namespace
128
129 KeyLayoutMap::KeyLayoutMap() = default;
130 KeyLayoutMap::~KeyLayoutMap() = default;
131
loadContents(const std::string & filename,const char * contents)132 base::Result<std::shared_ptr<KeyLayoutMap>> KeyLayoutMap::loadContents(const std::string& filename,
133 const char* contents) {
134 return load(filename, contents);
135 }
136
load(const std::string & filename,const char * contents)137 base::Result<std::shared_ptr<KeyLayoutMap>> KeyLayoutMap::load(const std::string& filename,
138 const char* contents) {
139 Tokenizer* tokenizer;
140 status_t status;
141 if (contents == nullptr) {
142 status = Tokenizer::open(String8(filename.c_str()), &tokenizer);
143 } else {
144 status = Tokenizer::fromContents(String8(filename.c_str()), contents, &tokenizer);
145 }
146 if (status) {
147 ALOGE("Error %d opening key layout map file %s.", status, filename.c_str());
148 return Errorf("Error {} opening key layout map file {}.", status, filename.c_str());
149 }
150 std::unique_ptr<Tokenizer> t(tokenizer);
151 auto ret = load(t.get());
152 if (!ret.ok()) {
153 return ret;
154 }
155 const std::shared_ptr<KeyLayoutMap>& map = *ret;
156 LOG_ALWAYS_FATAL_IF(map == nullptr, "Returned map should not be null if there's no error");
157 if (!kernelConfigsArePresent(map->mRequiredKernelConfigs)) {
158 ALOGI("Not loading %s because the required kernel configs are not set", filename.c_str());
159 return Errorf("Missing kernel config");
160 }
161 map->mLoadFileName = filename;
162 return ret;
163 }
164
load(Tokenizer * tokenizer)165 base::Result<std::shared_ptr<KeyLayoutMap>> KeyLayoutMap::load(Tokenizer* tokenizer) {
166 std::shared_ptr<KeyLayoutMap> map = std::shared_ptr<KeyLayoutMap>(new KeyLayoutMap());
167 status_t status = OK;
168 if (!map.get()) {
169 ALOGE("Error allocating key layout map.");
170 return Errorf("Error allocating key layout map.");
171 } else {
172 #if DEBUG_PARSER_PERFORMANCE
173 nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
174 #endif
175 Parser parser(map.get(), tokenizer);
176 status = parser.parse();
177 #if DEBUG_PARSER_PERFORMANCE
178 nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
179 ALOGD("Parsed key layout map file '%s' %d lines in %0.3fms.",
180 tokenizer->getFilename().string(), tokenizer->getLineNumber(),
181 elapsedTime / 1000000.0);
182 #endif
183 if (!status) {
184 return std::move(map);
185 }
186 }
187 return Errorf("Load KeyLayoutMap failed {}.", status);
188 }
189
mapKey(int32_t scanCode,int32_t usageCode,int32_t * outKeyCode,uint32_t * outFlags) const190 status_t KeyLayoutMap::mapKey(int32_t scanCode, int32_t usageCode,
191 int32_t* outKeyCode, uint32_t* outFlags) const {
192 const Key* key = getKey(scanCode, usageCode);
193 if (!key) {
194 ALOGD_IF(DEBUG_MAPPING, "mapKey: scanCode=%d, usageCode=0x%08x ~ Failed.", scanCode,
195 usageCode);
196 *outKeyCode = AKEYCODE_UNKNOWN;
197 *outFlags = 0;
198 return NAME_NOT_FOUND;
199 }
200
201 *outKeyCode = key->keyCode;
202 *outFlags = key->flags;
203
204 ALOGD_IF(DEBUG_MAPPING,
205 "mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d, outFlags=0x%08x.",
206 scanCode, usageCode, *outKeyCode, *outFlags);
207 return NO_ERROR;
208 }
209
210 // Return pair of sensor type and sensor data index, for the input device abs code
mapSensor(int32_t absCode) const211 base::Result<std::pair<InputDeviceSensorType, int32_t>> KeyLayoutMap::mapSensor(
212 int32_t absCode) const {
213 auto it = mSensorsByAbsCode.find(absCode);
214 if (it == mSensorsByAbsCode.end()) {
215 ALOGD_IF(DEBUG_MAPPING, "mapSensor: absCode=%d, ~ Failed.", absCode);
216 return Errorf("Can't find abs code {}.", absCode);
217 }
218 const Sensor& sensor = it->second;
219 ALOGD_IF(DEBUG_MAPPING, "mapSensor: absCode=%d, sensorType=%s, sensorDataIndex=0x%x.", absCode,
220 ftl::enum_string(sensor.sensorType).c_str(), sensor.sensorDataIndex);
221 return std::make_pair(sensor.sensorType, sensor.sensorDataIndex);
222 }
223
getKey(int32_t scanCode,int32_t usageCode) const224 const KeyLayoutMap::Key* KeyLayoutMap::getKey(int32_t scanCode, int32_t usageCode) const {
225 if (usageCode) {
226 auto it = mKeysByUsageCode.find(usageCode);
227 if (it != mKeysByUsageCode.end()) {
228 return &it->second;
229 }
230 }
231 if (scanCode) {
232 auto it = mKeysByScanCode.find(scanCode);
233 if (it != mKeysByScanCode.end()) {
234 return &it->second;
235 }
236 }
237 return nullptr;
238 }
239
findScanCodesForKey(int32_t keyCode) const240 std::vector<int32_t> KeyLayoutMap::findScanCodesForKey(int32_t keyCode) const {
241 std::vector<int32_t> scanCodes;
242 for (const auto& [scanCode, key] : mKeysByScanCode) {
243 if (keyCode == key.keyCode) {
244 scanCodes.push_back(scanCode);
245 }
246 }
247 return scanCodes;
248 }
249
findUsageCodesForKey(int32_t keyCode) const250 std::vector<int32_t> KeyLayoutMap::findUsageCodesForKey(int32_t keyCode) const {
251 std::vector<int32_t> usageCodes;
252 for (const auto& [usageCode, key] : mKeysByUsageCode) {
253 if (keyCode == key.keyCode) {
254 usageCodes.push_back(usageCode);
255 }
256 }
257 return usageCodes;
258 }
259
mapAxis(int32_t scanCode) const260 std::optional<AxisInfo> KeyLayoutMap::mapAxis(int32_t scanCode) const {
261 auto it = mAxes.find(scanCode);
262 if (it == mAxes.end()) {
263 ALOGD_IF(DEBUG_MAPPING, "mapAxis: scanCode=%d ~ Failed.", scanCode);
264 return std::nullopt;
265 }
266
267 const AxisInfo& axisInfo = it->second;
268 ALOGD_IF(DEBUG_MAPPING,
269 "mapAxis: scanCode=%d ~ Result mode=%d, axis=%d, highAxis=%d, "
270 "splitValue=%d, flatOverride=%d.",
271 scanCode, axisInfo.mode, axisInfo.axis, axisInfo.highAxis, axisInfo.splitValue,
272 axisInfo.flatOverride);
273 return axisInfo;
274 }
275
findScanCodeForLed(int32_t ledCode) const276 std::optional<int32_t> KeyLayoutMap::findScanCodeForLed(int32_t ledCode) const {
277 for (const auto& [scanCode, led] : mLedsByScanCode) {
278 if (led.ledCode == ledCode) {
279 ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d, scanCode=%d.", __func__, ledCode, scanCode);
280 return scanCode;
281 }
282 }
283 ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d ~ Not found.", __func__, ledCode);
284 return std::nullopt;
285 }
286
findUsageCodeForLed(int32_t ledCode) const287 std::optional<int32_t> KeyLayoutMap::findUsageCodeForLed(int32_t ledCode) const {
288 for (const auto& [usageCode, led] : mLedsByUsageCode) {
289 if (led.ledCode == ledCode) {
290 ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d, usage=%x.", __func__, ledCode, usageCode);
291 return usageCode;
292 }
293 }
294 ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d ~ Not found.", __func__, ledCode);
295 return std::nullopt;
296 }
297
298 // --- KeyLayoutMap::Parser ---
299
Parser(KeyLayoutMap * map,Tokenizer * tokenizer)300 KeyLayoutMap::Parser::Parser(KeyLayoutMap* map, Tokenizer* tokenizer) :
301 mMap(map), mTokenizer(tokenizer) {
302 }
303
~Parser()304 KeyLayoutMap::Parser::~Parser() {
305 }
306
parse()307 status_t KeyLayoutMap::Parser::parse() {
308 while (!mTokenizer->isEof()) {
309 ALOGD_IF(DEBUG_PARSER, "Parsing %s: '%s'.", mTokenizer->getLocation().string(),
310 mTokenizer->peekRemainderOfLine().string());
311
312 mTokenizer->skipDelimiters(WHITESPACE);
313
314 if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
315 String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
316 if (keywordToken == "key") {
317 mTokenizer->skipDelimiters(WHITESPACE);
318 status_t status = parseKey();
319 if (status) return status;
320 } else if (keywordToken == "axis") {
321 mTokenizer->skipDelimiters(WHITESPACE);
322 status_t status = parseAxis();
323 if (status) return status;
324 } else if (keywordToken == "led") {
325 mTokenizer->skipDelimiters(WHITESPACE);
326 status_t status = parseLed();
327 if (status) return status;
328 } else if (keywordToken == "sensor") {
329 mTokenizer->skipDelimiters(WHITESPACE);
330 status_t status = parseSensor();
331 if (status) return status;
332 } else if (keywordToken == "requires_kernel_config") {
333 mTokenizer->skipDelimiters(WHITESPACE);
334 status_t status = parseRequiredKernelConfig();
335 if (status) return status;
336 } else {
337 ALOGE("%s: Expected keyword, got '%s'.", mTokenizer->getLocation().string(),
338 keywordToken.string());
339 return BAD_VALUE;
340 }
341
342 mTokenizer->skipDelimiters(WHITESPACE);
343 if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
344 ALOGE("%s: Expected end of line or trailing comment, got '%s'.",
345 mTokenizer->getLocation().string(),
346 mTokenizer->peekRemainderOfLine().string());
347 return BAD_VALUE;
348 }
349 }
350
351 mTokenizer->nextLine();
352 }
353 return NO_ERROR;
354 }
355
parseKey()356 status_t KeyLayoutMap::Parser::parseKey() {
357 String8 codeToken = mTokenizer->nextToken(WHITESPACE);
358 bool mapUsage = false;
359 if (codeToken == "usage") {
360 mapUsage = true;
361 mTokenizer->skipDelimiters(WHITESPACE);
362 codeToken = mTokenizer->nextToken(WHITESPACE);
363 }
364
365 std::optional<int> code = parseInt(codeToken.string());
366 if (!code) {
367 ALOGE("%s: Expected key %s number, got '%s'.", mTokenizer->getLocation().string(),
368 mapUsage ? "usage" : "scan code", codeToken.string());
369 return BAD_VALUE;
370 }
371 std::unordered_map<int32_t, Key>& map =
372 mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;
373 if (map.find(*code) != map.end()) {
374 ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),
375 mapUsage ? "usage" : "scan code", codeToken.string());
376 return BAD_VALUE;
377 }
378
379 mTokenizer->skipDelimiters(WHITESPACE);
380 String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
381 std::optional<int> keyCode = InputEventLookup::getKeyCodeByLabel(keyCodeToken.string());
382 if (!keyCode) {
383 ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
384 keyCodeToken.string());
385 return BAD_VALUE;
386 }
387
388 uint32_t flags = 0;
389 for (;;) {
390 mTokenizer->skipDelimiters(WHITESPACE);
391 if (mTokenizer->isEol() || mTokenizer->peekChar() == '#') break;
392
393 String8 flagToken = mTokenizer->nextToken(WHITESPACE);
394 std::optional<int> flag = InputEventLookup::getKeyFlagByLabel(flagToken.string());
395 if (!flag) {
396 ALOGE("%s: Expected key flag label, got '%s'.", mTokenizer->getLocation().string(),
397 flagToken.string());
398 return BAD_VALUE;
399 }
400 if (flags & *flag) {
401 ALOGE("%s: Duplicate key flag '%s'.", mTokenizer->getLocation().string(),
402 flagToken.string());
403 return BAD_VALUE;
404 }
405 flags |= *flag;
406 }
407
408 ALOGD_IF(DEBUG_PARSER, "Parsed key %s: code=%d, keyCode=%d, flags=0x%08x.",
409 mapUsage ? "usage" : "scan code", *code, *keyCode, flags);
410
411 Key key;
412 key.keyCode = *keyCode;
413 key.flags = flags;
414 map.insert({*code, key});
415 return NO_ERROR;
416 }
417
parseAxis()418 status_t KeyLayoutMap::Parser::parseAxis() {
419 String8 scanCodeToken = mTokenizer->nextToken(WHITESPACE);
420 std::optional<int> scanCode = parseInt(scanCodeToken.string());
421 if (!scanCode) {
422 ALOGE("%s: Expected axis scan code number, got '%s'.", mTokenizer->getLocation().string(),
423 scanCodeToken.string());
424 return BAD_VALUE;
425 }
426 if (mMap->mAxes.find(*scanCode) != mMap->mAxes.end()) {
427 ALOGE("%s: Duplicate entry for axis scan code '%s'.", mTokenizer->getLocation().string(),
428 scanCodeToken.string());
429 return BAD_VALUE;
430 }
431
432 AxisInfo axisInfo;
433
434 mTokenizer->skipDelimiters(WHITESPACE);
435 String8 token = mTokenizer->nextToken(WHITESPACE);
436 if (token == "invert") {
437 axisInfo.mode = AxisInfo::MODE_INVERT;
438
439 mTokenizer->skipDelimiters(WHITESPACE);
440 String8 axisToken = mTokenizer->nextToken(WHITESPACE);
441 std::optional<int> axis = InputEventLookup::getAxisByLabel(axisToken.string());
442 if (!axis) {
443 ALOGE("%s: Expected inverted axis label, got '%s'.",
444 mTokenizer->getLocation().string(), axisToken.string());
445 return BAD_VALUE;
446 }
447 axisInfo.axis = *axis;
448 } else if (token == "split") {
449 axisInfo.mode = AxisInfo::MODE_SPLIT;
450
451 mTokenizer->skipDelimiters(WHITESPACE);
452 String8 splitToken = mTokenizer->nextToken(WHITESPACE);
453 std::optional<int> splitValue = parseInt(splitToken.string());
454 if (!splitValue) {
455 ALOGE("%s: Expected split value, got '%s'.",
456 mTokenizer->getLocation().string(), splitToken.string());
457 return BAD_VALUE;
458 }
459 axisInfo.splitValue = *splitValue;
460
461 mTokenizer->skipDelimiters(WHITESPACE);
462 String8 lowAxisToken = mTokenizer->nextToken(WHITESPACE);
463 std::optional<int> axis = InputEventLookup::getAxisByLabel(lowAxisToken.string());
464 if (!axis) {
465 ALOGE("%s: Expected low axis label, got '%s'.",
466 mTokenizer->getLocation().string(), lowAxisToken.string());
467 return BAD_VALUE;
468 }
469 axisInfo.axis = *axis;
470
471 mTokenizer->skipDelimiters(WHITESPACE);
472 String8 highAxisToken = mTokenizer->nextToken(WHITESPACE);
473 std::optional<int> highAxis = InputEventLookup::getAxisByLabel(highAxisToken.string());
474 if (!highAxis) {
475 ALOGE("%s: Expected high axis label, got '%s'.",
476 mTokenizer->getLocation().string(), highAxisToken.string());
477 return BAD_VALUE;
478 }
479 axisInfo.highAxis = *highAxis;
480 } else {
481 std::optional<int> axis = InputEventLookup::getAxisByLabel(token.string());
482 if (!axis) {
483 ALOGE("%s: Expected axis label, 'split' or 'invert', got '%s'.",
484 mTokenizer->getLocation().string(), token.string());
485 return BAD_VALUE;
486 }
487 axisInfo.axis = *axis;
488 }
489
490 for (;;) {
491 mTokenizer->skipDelimiters(WHITESPACE);
492 if (mTokenizer->isEol() || mTokenizer->peekChar() == '#') {
493 break;
494 }
495 String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
496 if (keywordToken == "flat") {
497 mTokenizer->skipDelimiters(WHITESPACE);
498 String8 flatToken = mTokenizer->nextToken(WHITESPACE);
499 std::optional<int> flatOverride = parseInt(flatToken.string());
500 if (!flatOverride) {
501 ALOGE("%s: Expected flat value, got '%s'.",
502 mTokenizer->getLocation().string(), flatToken.string());
503 return BAD_VALUE;
504 }
505 axisInfo.flatOverride = *flatOverride;
506 } else {
507 ALOGE("%s: Expected keyword 'flat', got '%s'.",
508 mTokenizer->getLocation().string(), keywordToken.string());
509 return BAD_VALUE;
510 }
511 }
512
513 ALOGD_IF(DEBUG_PARSER,
514 "Parsed axis: scanCode=%d, mode=%d, axis=%d, highAxis=%d, "
515 "splitValue=%d, flatOverride=%d.",
516 *scanCode, axisInfo.mode, axisInfo.axis, axisInfo.highAxis, axisInfo.splitValue,
517 axisInfo.flatOverride);
518 mMap->mAxes.insert({*scanCode, axisInfo});
519 return NO_ERROR;
520 }
521
parseLed()522 status_t KeyLayoutMap::Parser::parseLed() {
523 String8 codeToken = mTokenizer->nextToken(WHITESPACE);
524 bool mapUsage = false;
525 if (codeToken == "usage") {
526 mapUsage = true;
527 mTokenizer->skipDelimiters(WHITESPACE);
528 codeToken = mTokenizer->nextToken(WHITESPACE);
529 }
530 std::optional<int> code = parseInt(codeToken.string());
531 if (!code) {
532 ALOGE("%s: Expected led %s number, got '%s'.", mTokenizer->getLocation().string(),
533 mapUsage ? "usage" : "scan code", codeToken.string());
534 return BAD_VALUE;
535 }
536
537 std::unordered_map<int32_t, Led>& map =
538 mapUsage ? mMap->mLedsByUsageCode : mMap->mLedsByScanCode;
539 if (map.find(*code) != map.end()) {
540 ALOGE("%s: Duplicate entry for led %s '%s'.", mTokenizer->getLocation().string(),
541 mapUsage ? "usage" : "scan code", codeToken.string());
542 return BAD_VALUE;
543 }
544
545 mTokenizer->skipDelimiters(WHITESPACE);
546 String8 ledCodeToken = mTokenizer->nextToken(WHITESPACE);
547 std::optional<int> ledCode = InputEventLookup::getLedByLabel(ledCodeToken.string());
548 if (!ledCode) {
549 ALOGE("%s: Expected LED code label, got '%s'.", mTokenizer->getLocation().string(),
550 ledCodeToken.string());
551 return BAD_VALUE;
552 }
553
554 ALOGD_IF(DEBUG_PARSER, "Parsed led %s: code=%d, ledCode=%d.", mapUsage ? "usage" : "scan code",
555 *code, *ledCode);
556
557 Led led;
558 led.ledCode = *ledCode;
559 map.insert({*code, led});
560 return NO_ERROR;
561 }
562
getSensorType(const char * token)563 static std::optional<InputDeviceSensorType> getSensorType(const char* token) {
564 auto it = SENSOR_LIST.find(token);
565 if (it == SENSOR_LIST.end()) {
566 return std::nullopt;
567 }
568 return it->second;
569 }
570
getSensorDataIndex(String8 token)571 static std::optional<int32_t> getSensorDataIndex(String8 token) {
572 std::string tokenStr(token.string());
573 if (tokenStr == "X") {
574 return 0;
575 } else if (tokenStr == "Y") {
576 return 1;
577 } else if (tokenStr == "Z") {
578 return 2;
579 }
580 return std::nullopt;
581 }
582
583 // Parse sensor type and data index mapping, as below format
584 // sensor <raw abs> <sensor type> <sensor data index>
585 // raw abs : the linux abs code of the axis
586 // sensor type : string name of InputDeviceSensorType
587 // sensor data index : the data index of sensor, out of [X, Y, Z]
588 // Examples:
589 // sensor 0x00 ACCELEROMETER X
590 // sensor 0x01 ACCELEROMETER Y
591 // sensor 0x02 ACCELEROMETER Z
592 // sensor 0x03 GYROSCOPE X
593 // sensor 0x04 GYROSCOPE Y
594 // sensor 0x05 GYROSCOPE Z
parseSensor()595 status_t KeyLayoutMap::Parser::parseSensor() {
596 String8 codeToken = mTokenizer->nextToken(WHITESPACE);
597 std::optional<int> code = parseInt(codeToken.string());
598 if (!code) {
599 ALOGE("%s: Expected sensor %s number, got '%s'.", mTokenizer->getLocation().string(),
600 "abs code", codeToken.string());
601 return BAD_VALUE;
602 }
603
604 std::unordered_map<int32_t, Sensor>& map = mMap->mSensorsByAbsCode;
605 if (map.find(*code) != map.end()) {
606 ALOGE("%s: Duplicate entry for sensor %s '%s'.", mTokenizer->getLocation().string(),
607 "abs code", codeToken.string());
608 return BAD_VALUE;
609 }
610
611 mTokenizer->skipDelimiters(WHITESPACE);
612 String8 sensorTypeToken = mTokenizer->nextToken(WHITESPACE);
613 std::optional<InputDeviceSensorType> typeOpt = getSensorType(sensorTypeToken.string());
614 if (!typeOpt) {
615 ALOGE("%s: Expected sensor code label, got '%s'.", mTokenizer->getLocation().string(),
616 sensorTypeToken.string());
617 return BAD_VALUE;
618 }
619 InputDeviceSensorType sensorType = typeOpt.value();
620 mTokenizer->skipDelimiters(WHITESPACE);
621 String8 sensorDataIndexToken = mTokenizer->nextToken(WHITESPACE);
622 std::optional<int32_t> indexOpt = getSensorDataIndex(sensorDataIndexToken);
623 if (!indexOpt) {
624 ALOGE("%s: Expected sensor data index label, got '%s'.", mTokenizer->getLocation().string(),
625 sensorDataIndexToken.string());
626 return BAD_VALUE;
627 }
628 int32_t sensorDataIndex = indexOpt.value();
629
630 ALOGD_IF(DEBUG_PARSER, "Parsed sensor: abs code=%d, sensorType=%s, sensorDataIndex=%d.", *code,
631 ftl::enum_string(sensorType).c_str(), sensorDataIndex);
632
633 Sensor sensor;
634 sensor.sensorType = sensorType;
635 sensor.sensorDataIndex = sensorDataIndex;
636 map.emplace(*code, sensor);
637 return NO_ERROR;
638 }
639
640 // Parse the name of a required kernel config.
641 // The layout won't be used if the specified kernel config is not present
642 // Examples:
643 // requires_kernel_config CONFIG_HID_PLAYSTATION
parseRequiredKernelConfig()644 status_t KeyLayoutMap::Parser::parseRequiredKernelConfig() {
645 String8 codeToken = mTokenizer->nextToken(WHITESPACE);
646 std::string configName = codeToken.string();
647
648 const auto result = mMap->mRequiredKernelConfigs.emplace(configName);
649 if (!result.second) {
650 ALOGE("%s: Duplicate entry for required kernel config %s.",
651 mTokenizer->getLocation().string(), configName.c_str());
652 return BAD_VALUE;
653 }
654
655 ALOGD_IF(DEBUG_PARSER, "Parsed required kernel config: name=%s", configName.c_str());
656 return NO_ERROR;
657 }
658
659 } // namespace android
660