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 <stdlib.h>
20 
21 #include <android/keycodes.h>
22 #include <input/InputEventLabels.h>
23 #include <input/Keyboard.h>
24 #include <input/KeyLayoutMap.h>
25 #include <utils/Log.h>
26 #include <utils/Errors.h>
27 #include <utils/Tokenizer.h>
28 #include <utils/Timers.h>
29 
30 // Enables debug output for the parser.
31 #define DEBUG_PARSER 0
32 
33 // Enables debug output for parser performance.
34 #define DEBUG_PARSER_PERFORMANCE 0
35 
36 // Enables debug output for mapping.
37 #define DEBUG_MAPPING 0
38 
39 
40 namespace android {
41 
42 static const char* WHITESPACE = " \t\r";
43 
44 // --- KeyLayoutMap ---
45 
KeyLayoutMap()46 KeyLayoutMap::KeyLayoutMap() {
47 }
48 
~KeyLayoutMap()49 KeyLayoutMap::~KeyLayoutMap() {
50 }
51 
load(const std::string & filename,sp<KeyLayoutMap> * outMap)52 status_t KeyLayoutMap::load(const std::string& filename, sp<KeyLayoutMap>* outMap) {
53     outMap->clear();
54 
55     Tokenizer* tokenizer;
56     status_t status = Tokenizer::open(String8(filename.c_str()), &tokenizer);
57     if (status) {
58         ALOGE("Error %d opening key layout map file %s.", status, filename.c_str());
59     } else {
60         sp<KeyLayoutMap> map = new KeyLayoutMap();
61         if (!map.get()) {
62             ALOGE("Error allocating key layout map.");
63             status = NO_MEMORY;
64         } else {
65 #if DEBUG_PARSER_PERFORMANCE
66             nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);
67 #endif
68             Parser parser(map.get(), tokenizer);
69             status = parser.parse();
70 #if DEBUG_PARSER_PERFORMANCE
71             nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;
72             ALOGD("Parsed key layout map file '%s' %d lines in %0.3fms.",
73                     tokenizer->getFilename().string(), tokenizer->getLineNumber(),
74                     elapsedTime / 1000000.0);
75 #endif
76             if (!status) {
77                 *outMap = map;
78             }
79         }
80         delete tokenizer;
81     }
82     return status;
83 }
84 
mapKey(int32_t scanCode,int32_t usageCode,int32_t * outKeyCode,uint32_t * outFlags) const85 status_t KeyLayoutMap::mapKey(int32_t scanCode, int32_t usageCode,
86         int32_t* outKeyCode, uint32_t* outFlags) const {
87     const Key* key = getKey(scanCode, usageCode);
88     if (!key) {
89 #if DEBUG_MAPPING
90         ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Failed.", scanCode, usageCode);
91 #endif
92         *outKeyCode = AKEYCODE_UNKNOWN;
93         *outFlags = 0;
94         return NAME_NOT_FOUND;
95     }
96 
97     *outKeyCode = key->keyCode;
98     *outFlags = key->flags;
99 
100 #if DEBUG_MAPPING
101     ALOGD("mapKey: scanCode=%d, usageCode=0x%08x ~ Result keyCode=%d, outFlags=0x%08x.",
102             scanCode, usageCode, *outKeyCode, *outFlags);
103 #endif
104     return NO_ERROR;
105 }
106 
getKey(int32_t scanCode,int32_t usageCode) const107 const KeyLayoutMap::Key* KeyLayoutMap::getKey(int32_t scanCode, int32_t usageCode) const {
108     if (usageCode) {
109         ssize_t index = mKeysByUsageCode.indexOfKey(usageCode);
110         if (index >= 0) {
111             return &mKeysByUsageCode.valueAt(index);
112         }
113     }
114     if (scanCode) {
115         ssize_t index = mKeysByScanCode.indexOfKey(scanCode);
116         if (index >= 0) {
117             return &mKeysByScanCode.valueAt(index);
118         }
119     }
120     return nullptr;
121 }
122 
findScanCodesForKey(int32_t keyCode,std::vector<int32_t> * outScanCodes) const123 status_t KeyLayoutMap::findScanCodesForKey(
124         int32_t keyCode, std::vector<int32_t>* outScanCodes) const {
125     const size_t N = mKeysByScanCode.size();
126     for (size_t i=0; i<N; i++) {
127         if (mKeysByScanCode.valueAt(i).keyCode == keyCode) {
128             outScanCodes->push_back(mKeysByScanCode.keyAt(i));
129         }
130     }
131     return NO_ERROR;
132 }
133 
mapAxis(int32_t scanCode,AxisInfo * outAxisInfo) const134 status_t KeyLayoutMap::mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const {
135     ssize_t index = mAxes.indexOfKey(scanCode);
136     if (index < 0) {
137 #if DEBUG_MAPPING
138         ALOGD("mapAxis: scanCode=%d ~ Failed.", scanCode);
139 #endif
140         return NAME_NOT_FOUND;
141     }
142 
143     *outAxisInfo = mAxes.valueAt(index);
144 
145 #if DEBUG_MAPPING
146     ALOGD("mapAxis: scanCode=%d ~ Result mode=%d, axis=%d, highAxis=%d, "
147             "splitValue=%d, flatOverride=%d.",
148             scanCode,
149             outAxisInfo->mode, outAxisInfo->axis, outAxisInfo->highAxis,
150             outAxisInfo->splitValue, outAxisInfo->flatOverride);
151 #endif
152     return NO_ERROR;
153 }
154 
findScanCodeForLed(int32_t ledCode,int32_t * outScanCode) const155 status_t KeyLayoutMap::findScanCodeForLed(int32_t ledCode, int32_t* outScanCode) const {
156     const size_t N = mLedsByScanCode.size();
157     for (size_t i = 0; i < N; i++) {
158         if (mLedsByScanCode.valueAt(i).ledCode == ledCode) {
159             *outScanCode = mLedsByScanCode.keyAt(i);
160 #if DEBUG_MAPPING
161             ALOGD("findScanCodeForLed: ledCode=%d, scanCode=%d.", ledCode, *outScanCode);
162 #endif
163             return NO_ERROR;
164         }
165     }
166 #if DEBUG_MAPPING
167             ALOGD("findScanCodeForLed: ledCode=%d ~ Not found.", ledCode);
168 #endif
169     return NAME_NOT_FOUND;
170 }
171 
findUsageCodeForLed(int32_t ledCode,int32_t * outUsageCode) const172 status_t KeyLayoutMap::findUsageCodeForLed(int32_t ledCode, int32_t* outUsageCode) const {
173     const size_t N = mLedsByUsageCode.size();
174     for (size_t i = 0; i < N; i++) {
175         if (mLedsByUsageCode.valueAt(i).ledCode == ledCode) {
176             *outUsageCode = mLedsByUsageCode.keyAt(i);
177 #if DEBUG_MAPPING
178             ALOGD("findUsageForLed: ledCode=%d, usage=%x.", ledCode, *outUsageCode);
179 #endif
180             return NO_ERROR;
181         }
182     }
183 #if DEBUG_MAPPING
184             ALOGD("findUsageForLed: ledCode=%d ~ Not found.", ledCode);
185 #endif
186     return NAME_NOT_FOUND;
187 }
188 
189 
190 // --- KeyLayoutMap::Parser ---
191 
Parser(KeyLayoutMap * map,Tokenizer * tokenizer)192 KeyLayoutMap::Parser::Parser(KeyLayoutMap* map, Tokenizer* tokenizer) :
193         mMap(map), mTokenizer(tokenizer) {
194 }
195 
~Parser()196 KeyLayoutMap::Parser::~Parser() {
197 }
198 
parse()199 status_t KeyLayoutMap::Parser::parse() {
200     while (!mTokenizer->isEof()) {
201 #if DEBUG_PARSER
202         ALOGD("Parsing %s: '%s'.", mTokenizer->getLocation().string(),
203                 mTokenizer->peekRemainderOfLine().string());
204 #endif
205 
206         mTokenizer->skipDelimiters(WHITESPACE);
207 
208         if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
209             String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
210             if (keywordToken == "key") {
211                 mTokenizer->skipDelimiters(WHITESPACE);
212                 status_t status = parseKey();
213                 if (status) return status;
214             } else if (keywordToken == "axis") {
215                 mTokenizer->skipDelimiters(WHITESPACE);
216                 status_t status = parseAxis();
217                 if (status) return status;
218             } else if (keywordToken == "led") {
219                 mTokenizer->skipDelimiters(WHITESPACE);
220                 status_t status = parseLed();
221                 if (status) return status;
222             } else {
223                 ALOGE("%s: Expected keyword, got '%s'.", mTokenizer->getLocation().string(),
224                         keywordToken.string());
225                 return BAD_VALUE;
226             }
227 
228             mTokenizer->skipDelimiters(WHITESPACE);
229             if (!mTokenizer->isEol() && mTokenizer->peekChar() != '#') {
230                 ALOGE("%s: Expected end of line or trailing comment, got '%s'.",
231                         mTokenizer->getLocation().string(),
232                         mTokenizer->peekRemainderOfLine().string());
233                 return BAD_VALUE;
234             }
235         }
236 
237         mTokenizer->nextLine();
238     }
239     return NO_ERROR;
240 }
241 
parseKey()242 status_t KeyLayoutMap::Parser::parseKey() {
243     String8 codeToken = mTokenizer->nextToken(WHITESPACE);
244     bool mapUsage = false;
245     if (codeToken == "usage") {
246         mapUsage = true;
247         mTokenizer->skipDelimiters(WHITESPACE);
248         codeToken = mTokenizer->nextToken(WHITESPACE);
249     }
250 
251     char* end;
252     int32_t code = int32_t(strtol(codeToken.string(), &end, 0));
253     if (*end) {
254         ALOGE("%s: Expected key %s number, got '%s'.", mTokenizer->getLocation().string(),
255                 mapUsage ? "usage" : "scan code", codeToken.string());
256         return BAD_VALUE;
257     }
258     KeyedVector<int32_t, Key>& map = mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;
259     if (map.indexOfKey(code) >= 0) {
260         ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),
261                 mapUsage ? "usage" : "scan code", codeToken.string());
262         return BAD_VALUE;
263     }
264 
265     mTokenizer->skipDelimiters(WHITESPACE);
266     String8 keyCodeToken = mTokenizer->nextToken(WHITESPACE);
267     int32_t keyCode = getKeyCodeByLabel(keyCodeToken.string());
268     if (!keyCode) {
269         ALOGE("%s: Expected key code label, got '%s'.", mTokenizer->getLocation().string(),
270                 keyCodeToken.string());
271         return BAD_VALUE;
272     }
273 
274     uint32_t flags = 0;
275     for (;;) {
276         mTokenizer->skipDelimiters(WHITESPACE);
277         if (mTokenizer->isEol() || mTokenizer->peekChar() == '#') break;
278 
279         String8 flagToken = mTokenizer->nextToken(WHITESPACE);
280         uint32_t flag = getKeyFlagByLabel(flagToken.string());
281         if (!flag) {
282             ALOGE("%s: Expected key flag label, got '%s'.", mTokenizer->getLocation().string(),
283                     flagToken.string());
284             return BAD_VALUE;
285         }
286         if (flags & flag) {
287             ALOGE("%s: Duplicate key flag '%s'.", mTokenizer->getLocation().string(),
288                     flagToken.string());
289             return BAD_VALUE;
290         }
291         flags |= flag;
292     }
293 
294 #if DEBUG_PARSER
295     ALOGD("Parsed key %s: code=%d, keyCode=%d, flags=0x%08x.",
296             mapUsage ? "usage" : "scan code", code, keyCode, flags);
297 #endif
298     Key key;
299     key.keyCode = keyCode;
300     key.flags = flags;
301     map.add(code, key);
302     return NO_ERROR;
303 }
304 
parseAxis()305 status_t KeyLayoutMap::Parser::parseAxis() {
306     String8 scanCodeToken = mTokenizer->nextToken(WHITESPACE);
307     char* end;
308     int32_t scanCode = int32_t(strtol(scanCodeToken.string(), &end, 0));
309     if (*end) {
310         ALOGE("%s: Expected axis scan code number, got '%s'.", mTokenizer->getLocation().string(),
311                 scanCodeToken.string());
312         return BAD_VALUE;
313     }
314     if (mMap->mAxes.indexOfKey(scanCode) >= 0) {
315         ALOGE("%s: Duplicate entry for axis scan code '%s'.", mTokenizer->getLocation().string(),
316                 scanCodeToken.string());
317         return BAD_VALUE;
318     }
319 
320     AxisInfo axisInfo;
321 
322     mTokenizer->skipDelimiters(WHITESPACE);
323     String8 token = mTokenizer->nextToken(WHITESPACE);
324     if (token == "invert") {
325         axisInfo.mode = AxisInfo::MODE_INVERT;
326 
327         mTokenizer->skipDelimiters(WHITESPACE);
328         String8 axisToken = mTokenizer->nextToken(WHITESPACE);
329         axisInfo.axis = getAxisByLabel(axisToken.string());
330         if (axisInfo.axis < 0) {
331             ALOGE("%s: Expected inverted axis label, got '%s'.",
332                     mTokenizer->getLocation().string(), axisToken.string());
333             return BAD_VALUE;
334         }
335     } else if (token == "split") {
336         axisInfo.mode = AxisInfo::MODE_SPLIT;
337 
338         mTokenizer->skipDelimiters(WHITESPACE);
339         String8 splitToken = mTokenizer->nextToken(WHITESPACE);
340         axisInfo.splitValue = int32_t(strtol(splitToken.string(), &end, 0));
341         if (*end) {
342             ALOGE("%s: Expected split value, got '%s'.",
343                     mTokenizer->getLocation().string(), splitToken.string());
344             return BAD_VALUE;
345         }
346 
347         mTokenizer->skipDelimiters(WHITESPACE);
348         String8 lowAxisToken = mTokenizer->nextToken(WHITESPACE);
349         axisInfo.axis = getAxisByLabel(lowAxisToken.string());
350         if (axisInfo.axis < 0) {
351             ALOGE("%s: Expected low axis label, got '%s'.",
352                     mTokenizer->getLocation().string(), lowAxisToken.string());
353             return BAD_VALUE;
354         }
355 
356         mTokenizer->skipDelimiters(WHITESPACE);
357         String8 highAxisToken = mTokenizer->nextToken(WHITESPACE);
358         axisInfo.highAxis = getAxisByLabel(highAxisToken.string());
359         if (axisInfo.highAxis < 0) {
360             ALOGE("%s: Expected high axis label, got '%s'.",
361                     mTokenizer->getLocation().string(), highAxisToken.string());
362             return BAD_VALUE;
363         }
364     } else {
365         axisInfo.axis = getAxisByLabel(token.string());
366         if (axisInfo.axis < 0) {
367             ALOGE("%s: Expected axis label, 'split' or 'invert', got '%s'.",
368                     mTokenizer->getLocation().string(), token.string());
369             return BAD_VALUE;
370         }
371     }
372 
373     for (;;) {
374         mTokenizer->skipDelimiters(WHITESPACE);
375         if (mTokenizer->isEol() || mTokenizer->peekChar() == '#') {
376             break;
377         }
378         String8 keywordToken = mTokenizer->nextToken(WHITESPACE);
379         if (keywordToken == "flat") {
380             mTokenizer->skipDelimiters(WHITESPACE);
381             String8 flatToken = mTokenizer->nextToken(WHITESPACE);
382             axisInfo.flatOverride = int32_t(strtol(flatToken.string(), &end, 0));
383             if (*end) {
384                 ALOGE("%s: Expected flat value, got '%s'.",
385                         mTokenizer->getLocation().string(), flatToken.string());
386                 return BAD_VALUE;
387             }
388         } else {
389             ALOGE("%s: Expected keyword 'flat', got '%s'.",
390                     mTokenizer->getLocation().string(), keywordToken.string());
391             return BAD_VALUE;
392         }
393     }
394 
395 #if DEBUG_PARSER
396     ALOGD("Parsed axis: scanCode=%d, mode=%d, axis=%d, highAxis=%d, "
397             "splitValue=%d, flatOverride=%d.",
398             scanCode,
399             axisInfo.mode, axisInfo.axis, axisInfo.highAxis,
400             axisInfo.splitValue, axisInfo.flatOverride);
401 #endif
402     mMap->mAxes.add(scanCode, axisInfo);
403     return NO_ERROR;
404 }
405 
parseLed()406 status_t KeyLayoutMap::Parser::parseLed() {
407     String8 codeToken = mTokenizer->nextToken(WHITESPACE);
408     bool mapUsage = false;
409     if (codeToken == "usage") {
410         mapUsage = true;
411         mTokenizer->skipDelimiters(WHITESPACE);
412         codeToken = mTokenizer->nextToken(WHITESPACE);
413     }
414     char* end;
415     int32_t code = int32_t(strtol(codeToken.string(), &end, 0));
416     if (*end) {
417         ALOGE("%s: Expected led %s number, got '%s'.", mTokenizer->getLocation().string(),
418                 mapUsage ? "usage" : "scan code", codeToken.string());
419         return BAD_VALUE;
420     }
421 
422     KeyedVector<int32_t, Led>& map = mapUsage ? mMap->mLedsByUsageCode : mMap->mLedsByScanCode;
423     if (map.indexOfKey(code) >= 0) {
424         ALOGE("%s: Duplicate entry for led %s '%s'.", mTokenizer->getLocation().string(),
425                 mapUsage ? "usage" : "scan code", codeToken.string());
426         return BAD_VALUE;
427     }
428 
429     mTokenizer->skipDelimiters(WHITESPACE);
430     String8 ledCodeToken = mTokenizer->nextToken(WHITESPACE);
431     int32_t ledCode = getLedByLabel(ledCodeToken.string());
432     if (ledCode < 0) {
433         ALOGE("%s: Expected LED code label, got '%s'.", mTokenizer->getLocation().string(),
434                 ledCodeToken.string());
435         return BAD_VALUE;
436     }
437 
438 #if DEBUG_PARSER
439     ALOGD("Parsed led %s: code=%d, ledCode=%d.",
440             mapUsage ? "usage" : "scan code", code, ledCode);
441 #endif
442 
443     Led led;
444     led.ledCode = ledCode;
445     map.add(code, led);
446     return NO_ERROR;
447 }
448 };
449