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 #ifndef _LIBINPUT_KEY_LAYOUT_MAP_H 18 #define _LIBINPUT_KEY_LAYOUT_MAP_H 19 20 #include <android-base/result.h> 21 #include <stdint.h> 22 #include <utils/Errors.h> 23 #include <utils/KeyedVector.h> 24 #include <utils/Tokenizer.h> 25 #include <set> 26 27 #include <input/InputDevice.h> 28 29 namespace android { 30 31 struct AxisInfo { 32 enum Mode { 33 // Axis value is reported directly. 34 MODE_NORMAL = 0, 35 // Axis value should be inverted before reporting. 36 MODE_INVERT = 1, 37 // Axis value should be split into two axes 38 MODE_SPLIT = 2, 39 }; 40 41 // Axis mode. 42 Mode mode; 43 44 // Axis id. 45 // When split, this is the axis used for values smaller than the split position. 46 int32_t axis; 47 48 // When split, this is the axis used for values after higher than the split position. 49 int32_t highAxis; 50 51 // The split value, or 0 if not split. 52 int32_t splitValue; 53 54 // The flat value, or -1 if none. 55 int32_t flatOverride; 56 AxisInfoAxisInfo57 AxisInfo() : mode(MODE_NORMAL), axis(-1), highAxis(-1), splitValue(0), flatOverride(-1) { 58 } 59 }; 60 61 /** 62 * Describes a mapping from keyboard scan codes and joystick axes to Android key codes and axes. 63 * 64 * This object is immutable after it has been loaded. 65 */ 66 class KeyLayoutMap { 67 public: 68 static base::Result<std::shared_ptr<KeyLayoutMap>> load(const std::string& filename, 69 const char* contents = nullptr); 70 static base::Result<std::shared_ptr<KeyLayoutMap>> loadContents(const std::string& filename, 71 const char* contents); 72 73 status_t mapKey(int32_t scanCode, int32_t usageCode, 74 int32_t* outKeyCode, uint32_t* outFlags) const; 75 status_t findScanCodesForKey(int32_t keyCode, std::vector<int32_t>* outScanCodes) const; 76 status_t findScanCodeForLed(int32_t ledCode, int32_t* outScanCode) const; 77 status_t findUsageCodeForLed(int32_t ledCode, int32_t* outUsageCode) const; 78 79 status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const; 80 const std::string getLoadFileName() const; 81 // Return pair of sensor type and sensor data index, for the input device abs code 82 base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode); 83 84 virtual ~KeyLayoutMap(); 85 86 private: 87 static base::Result<std::shared_ptr<KeyLayoutMap>> load(Tokenizer* tokenizer); 88 89 struct Key { 90 int32_t keyCode; 91 uint32_t flags; 92 }; 93 94 struct Led { 95 int32_t ledCode; 96 }; 97 98 struct Sensor { 99 InputDeviceSensorType sensorType; 100 int32_t sensorDataIndex; 101 }; 102 103 KeyedVector<int32_t, Key> mKeysByScanCode; 104 KeyedVector<int32_t, Key> mKeysByUsageCode; 105 KeyedVector<int32_t, AxisInfo> mAxes; 106 KeyedVector<int32_t, Led> mLedsByScanCode; 107 KeyedVector<int32_t, Led> mLedsByUsageCode; 108 std::unordered_map<int32_t, Sensor> mSensorsByAbsCode; 109 std::set<std::string> mRequiredKernelConfigs; 110 std::string mLoadFileName; 111 112 KeyLayoutMap(); 113 114 const Key* getKey(int32_t scanCode, int32_t usageCode) const; 115 116 class Parser { 117 KeyLayoutMap* mMap; 118 Tokenizer* mTokenizer; 119 120 public: 121 Parser(KeyLayoutMap* map, Tokenizer* tokenizer); 122 ~Parser(); 123 status_t parse(); 124 125 private: 126 status_t parseKey(); 127 status_t parseAxis(); 128 status_t parseLed(); 129 status_t parseSensor(); 130 status_t parseRequiredKernelConfig(); 131 }; 132 }; 133 134 } // namespace android 135 136 #endif // _LIBINPUT_KEY_LAYOUT_MAP_H 137