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