Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 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 | |
Mark Salyzyn | 5aa26b2 | 2014-06-10 13:07:44 -0700 | [diff] [blame] | 17 | #include <assert.h> |
| 18 | #include <dirent.h> |
| 19 | #include <errno.h> |
| 20 | #include <fcntl.h> |
| 21 | #include <inttypes.h> |
| 22 | #include <memory.h> |
| 23 | #include <stdint.h> |
| 24 | #include <stdio.h> |
| 25 | #include <stdlib.h> |
| 26 | #include <string.h> |
Siarhei Vishniakou | 7a522bf | 2019-09-24 12:46:29 +0100 | [diff] [blame] | 27 | #include <sys/capability.h> |
Mark Salyzyn | 5aa26b2 | 2014-06-10 13:07:44 -0700 | [diff] [blame] | 28 | #include <sys/epoll.h> |
Mark Salyzyn | 5aa26b2 | 2014-06-10 13:07:44 -0700 | [diff] [blame] | 29 | #include <sys/inotify.h> |
| 30 | #include <sys/ioctl.h> |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 31 | #include <sys/limits.h> |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 32 | #include <sys/stat.h> |
| 33 | #include <sys/sysmacros.h> |
Mark Salyzyn | 5aa26b2 | 2014-06-10 13:07:44 -0700 | [diff] [blame] | 34 | #include <unistd.h> |
| 35 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 36 | #define LOG_TAG "EventHub" |
| 37 | |
| 38 | // #define LOG_NDEBUG 0 |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 39 | #include <android-base/file.h> |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 40 | #include <android-base/stringprintf.h> |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 41 | #include <android-base/strings.h> |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 42 | #include <cutils/properties.h> |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 43 | #include <input/KeyCharacterMap.h> |
| 44 | #include <input/KeyLayoutMap.h> |
| 45 | #include <input/VirtualKeyMap.h> |
Dan Albert | 677d87e | 2014-06-16 17:31:28 -0700 | [diff] [blame] | 46 | #include <openssl/sha.h> |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 47 | #include <statslog.h> |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 48 | #include <utils/Errors.h> |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 49 | #include <utils/Log.h> |
| 50 | #include <utils/Timers.h> |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 51 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 52 | #include <filesystem> |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 53 | #include <regex> |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 54 | |
| 55 | #include "EventHub.h" |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 56 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 57 | #define INDENT " " |
| 58 | #define INDENT2 " " |
| 59 | #define INDENT3 " " |
| 60 | |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 61 | using android::base::StringPrintf; |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 62 | using namespace android::flag_operators; |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 63 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 64 | namespace android { |
| 65 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 66 | static const char* DEVICE_PATH = "/dev/input"; |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 67 | // v4l2 devices go directly into /dev |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 68 | static const char* VIDEO_DEVICE_PATH = "/dev"; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 69 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 70 | static constexpr int32_t FF_STRONG_MAGNITUDE_CHANNEL_IDX = 0; |
| 71 | static constexpr int32_t FF_WEAK_MAGNITUDE_CHANNEL_IDX = 1; |
Chris Ye | 6393a26 | 2020-08-04 19:41:36 -0700 | [diff] [blame] | 72 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 73 | // Mapping for input battery class node IDs lookup. |
| 74 | // https://www.kernel.org/doc/Documentation/power/power_supply_class.txt |
| 75 | static const std::unordered_map<std::string, InputBatteryClass> BATTERY_CLASSES = |
| 76 | {{"capacity", InputBatteryClass::CAPACITY}, |
| 77 | {"capacity_level", InputBatteryClass::CAPACITY_LEVEL}, |
| 78 | {"status", InputBatteryClass::STATUS}}; |
| 79 | |
| 80 | // Mapping for input battery class node names lookup. |
| 81 | // https://www.kernel.org/doc/Documentation/power/power_supply_class.txt |
| 82 | static const std::unordered_map<InputBatteryClass, std::string> BATTERY_NODES = |
| 83 | {{InputBatteryClass::CAPACITY, "capacity"}, |
| 84 | {InputBatteryClass::CAPACITY_LEVEL, "capacity_level"}, |
| 85 | {InputBatteryClass::STATUS, "status"}}; |
| 86 | |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 87 | // must be kept in sync with definitions in kernel /drivers/power/supply/power_supply_sysfs.c |
| 88 | static const std::unordered_map<std::string, int32_t> BATTERY_STATUS = |
| 89 | {{"Unknown", BATTERY_STATUS_UNKNOWN}, |
| 90 | {"Charging", BATTERY_STATUS_CHARGING}, |
| 91 | {"Discharging", BATTERY_STATUS_DISCHARGING}, |
| 92 | {"Not charging", BATTERY_STATUS_NOT_CHARGING}, |
| 93 | {"Full", BATTERY_STATUS_FULL}}; |
| 94 | |
| 95 | // Mapping taken from |
| 96 | // https://gitlab.freedesktop.org/upower/upower/-/blob/master/src/linux/up-device-supply.c#L484 |
| 97 | static const std::unordered_map<std::string, int32_t> BATTERY_LEVEL = {{"Critical", 5}, |
| 98 | {"Low", 10}, |
| 99 | {"Normal", 55}, |
| 100 | {"High", 70}, |
| 101 | {"Full", 100}, |
| 102 | {"Unknown", 50}}; |
| 103 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 104 | // Mapping for input led class node names lookup. |
| 105 | // https://www.kernel.org/doc/html/latest/leds/leds-class.html |
| 106 | static const std::unordered_map<std::string, InputLightClass> LIGHT_CLASSES = |
| 107 | {{"red", InputLightClass::RED}, |
| 108 | {"green", InputLightClass::GREEN}, |
| 109 | {"blue", InputLightClass::BLUE}, |
| 110 | {"global", InputLightClass::GLOBAL}, |
| 111 | {"brightness", InputLightClass::BRIGHTNESS}, |
| 112 | {"multi_index", InputLightClass::MULTI_INDEX}, |
| 113 | {"multi_intensity", InputLightClass::MULTI_INTENSITY}, |
| 114 | {"max_brightness", InputLightClass::MAX_BRIGHTNESS}}; |
| 115 | |
| 116 | // Mapping for input multicolor led class node names. |
| 117 | // https://www.kernel.org/doc/html/latest/leds/leds-class-multicolor.html |
| 118 | static const std::unordered_map<InputLightClass, std::string> LIGHT_NODES = |
| 119 | {{InputLightClass::BRIGHTNESS, "brightness"}, |
| 120 | {InputLightClass::MULTI_INDEX, "multi_index"}, |
| 121 | {InputLightClass::MULTI_INTENSITY, "multi_intensity"}}; |
| 122 | |
| 123 | // Mapping for light color name and the light color |
| 124 | const std::unordered_map<std::string, LightColor> LIGHT_COLORS = {{"red", LightColor::RED}, |
| 125 | {"green", LightColor::GREEN}, |
| 126 | {"blue", LightColor::BLUE}}; |
| 127 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 128 | static inline const char* toString(bool value) { |
| 129 | return value ? "true" : "false"; |
| 130 | } |
| 131 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 132 | static std::string sha1(const std::string& in) { |
Dan Albert | 677d87e | 2014-06-16 17:31:28 -0700 | [diff] [blame] | 133 | SHA_CTX ctx; |
| 134 | SHA1_Init(&ctx); |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 135 | SHA1_Update(&ctx, reinterpret_cast<const u_char*>(in.c_str()), in.size()); |
Dan Albert | 677d87e | 2014-06-16 17:31:28 -0700 | [diff] [blame] | 136 | u_char digest[SHA_DIGEST_LENGTH]; |
| 137 | SHA1_Final(digest, &ctx); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 138 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 139 | std::string out; |
Dan Albert | 677d87e | 2014-06-16 17:31:28 -0700 | [diff] [blame] | 140 | for (size_t i = 0; i < SHA_DIGEST_LENGTH; i++) { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 141 | out += StringPrintf("%02x", digest[i]); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 142 | } |
| 143 | return out; |
| 144 | } |
| 145 | |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 146 | /** |
| 147 | * Return true if name matches "v4l-touch*" |
| 148 | */ |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 149 | static bool isV4lTouchNode(std::string name) { |
| 150 | return name.find("v4l-touch") != std::string::npos; |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 151 | } |
| 152 | |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 153 | /** |
| 154 | * Returns true if V4L devices should be scanned. |
| 155 | * |
| 156 | * The system property ro.input.video_enabled can be used to control whether |
| 157 | * EventHub scans and opens V4L devices. As V4L does not support multiple |
| 158 | * clients, EventHub effectively blocks access to these devices when it opens |
Siarhei Vishniakou | 29f8849 | 2019-04-05 14:11:43 -0700 | [diff] [blame] | 159 | * them. |
| 160 | * |
| 161 | * Setting this to "false" would prevent any video devices from being discovered and |
| 162 | * associated with input devices. |
| 163 | * |
| 164 | * This property can be used as follows: |
| 165 | * 1. To turn off features that are dependent on video device presence. |
| 166 | * 2. During testing and development, to allow other clients to read video devices |
| 167 | * directly from /dev. |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 168 | */ |
| 169 | static bool isV4lScanningEnabled() { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 170 | return property_get_bool("ro.input.video_enabled", true /* default_value */); |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 171 | } |
| 172 | |
Siarhei Vishniakou | 592bac2 | 2018-11-08 19:42:38 -0800 | [diff] [blame] | 173 | static nsecs_t processEventTimestamp(const struct input_event& event) { |
| 174 | // Use the time specified in the event instead of the current time |
| 175 | // so that downstream code can get more accurate estimates of |
| 176 | // event dispatch latency from the time the event is enqueued onto |
| 177 | // the evdev client buffer. |
| 178 | // |
| 179 | // The event's timestamp fortuitously uses the same monotonic clock |
| 180 | // time base as the rest of Android. The kernel event device driver |
| 181 | // (drivers/input/evdev.c) obtains timestamps using ktime_get_ts(). |
| 182 | // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere |
| 183 | // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a |
| 184 | // system call that also queries ktime_get_ts(). |
| 185 | |
| 186 | const nsecs_t inputEventTime = seconds_to_nanoseconds(event.time.tv_sec) + |
| 187 | microseconds_to_nanoseconds(event.time.tv_usec); |
| 188 | return inputEventTime; |
| 189 | } |
| 190 | |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 191 | /** |
| 192 | * Returns the sysfs root path of the input device |
| 193 | * |
| 194 | */ |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 195 | static std::optional<std::filesystem::path> getSysfsRootPath(const char* devicePath) { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 196 | std::error_code errorCode; |
| 197 | |
| 198 | // Stat the device path to get the major and minor number of the character file |
| 199 | struct stat statbuf; |
| 200 | if (stat(devicePath, &statbuf) == -1) { |
| 201 | ALOGE("Could not stat device %s due to error: %s.", devicePath, std::strerror(errno)); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 202 | return std::nullopt; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | unsigned int major_num = major(statbuf.st_rdev); |
| 206 | unsigned int minor_num = minor(statbuf.st_rdev); |
| 207 | |
| 208 | // Realpath "/sys/dev/char/{major}:{minor}" to get the sysfs path to the input event |
| 209 | auto sysfsPath = std::filesystem::path("/sys/dev/char/"); |
| 210 | sysfsPath /= std::to_string(major_num) + ":" + std::to_string(minor_num); |
| 211 | sysfsPath = std::filesystem::canonical(sysfsPath, errorCode); |
| 212 | |
| 213 | // Make sure nothing went wrong in call to canonical() |
| 214 | if (errorCode) { |
| 215 | ALOGW("Could not run filesystem::canonical() due to error %d : %s.", errorCode.value(), |
| 216 | errorCode.message().c_str()); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 217 | return std::nullopt; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | // Continue to go up a directory until we reach a directory named "input" |
| 221 | while (sysfsPath != "/" && sysfsPath.filename() != "input") { |
| 222 | sysfsPath = sysfsPath.parent_path(); |
| 223 | } |
| 224 | |
| 225 | // Then go up one more and you will be at the sysfs root of the device |
| 226 | sysfsPath = sysfsPath.parent_path(); |
| 227 | |
| 228 | // Make sure we didn't reach root path and that directory actually exists |
| 229 | if (sysfsPath == "/" || !std::filesystem::exists(sysfsPath, errorCode)) { |
| 230 | if (errorCode) { |
| 231 | ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(), |
| 232 | errorCode.message().c_str()); |
| 233 | } |
| 234 | |
| 235 | // Not found |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 236 | return std::nullopt; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | return sysfsPath; |
| 240 | } |
| 241 | |
| 242 | /** |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 243 | * Returns the list of files under a specified path. |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 244 | */ |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 245 | static std::vector<std::filesystem::path> allFilesInPath(const std::filesystem::path& path) { |
| 246 | std::vector<std::filesystem::path> nodes; |
| 247 | std::error_code errorCode; |
| 248 | auto iter = std::filesystem::directory_iterator(path, errorCode); |
| 249 | while (!errorCode && iter != std::filesystem::directory_iterator()) { |
| 250 | nodes.push_back(iter->path()); |
| 251 | iter++; |
| 252 | } |
| 253 | return nodes; |
| 254 | } |
| 255 | |
| 256 | /** |
| 257 | * Returns the list of files under a specified directory in a sysfs path. |
| 258 | * Example: |
| 259 | * findSysfsNodes(sysfsRootPath, SysfsClass::LEDS) will return all led nodes under "leds" directory |
| 260 | * in the sysfs path. |
| 261 | */ |
| 262 | static std::vector<std::filesystem::path> findSysfsNodes(const std::filesystem::path& sysfsRoot, |
| 263 | SysfsClass clazz) { |
| 264 | std::string nodeStr = NamedEnum::string(clazz); |
| 265 | std::for_each(nodeStr.begin(), nodeStr.end(), |
| 266 | [](char& c) { c = std::tolower(static_cast<unsigned char>(c)); }); |
| 267 | std::vector<std::filesystem::path> nodes; |
| 268 | for (auto path = sysfsRoot; path != "/" && nodes.empty(); path = path.parent_path()) { |
| 269 | nodes = allFilesInPath(path / nodeStr); |
| 270 | } |
| 271 | return nodes; |
| 272 | } |
| 273 | |
| 274 | static std::optional<std::array<LightColor, COLOR_NUM>> getColorIndexArray( |
| 275 | std::filesystem::path path) { |
| 276 | std::string indexStr; |
| 277 | if (!base::ReadFileToString(path, &indexStr)) { |
| 278 | return std::nullopt; |
| 279 | } |
| 280 | |
| 281 | // Parse the multi color LED index file, refer to kernel docs |
| 282 | // leds/leds-class-multicolor.html |
| 283 | std::regex indexPattern("(red|green|blue)\\s(red|green|blue)\\s(red|green|blue)[\\n]"); |
| 284 | std::smatch results; |
| 285 | std::array<LightColor, COLOR_NUM> colors; |
| 286 | if (!std::regex_match(indexStr, results, indexPattern)) { |
| 287 | return std::nullopt; |
| 288 | } |
| 289 | |
| 290 | for (size_t i = 1; i < results.size(); i++) { |
| 291 | const auto it = LIGHT_COLORS.find(results[i].str()); |
| 292 | if (it != LIGHT_COLORS.end()) { |
| 293 | // intensities.emplace(it->second, 0); |
| 294 | colors[i - 1] = it->second; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 295 | } |
| 296 | } |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 297 | return colors; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 298 | } |
| 299 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 300 | // --- Global Functions --- |
| 301 | |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 302 | Flags<InputDeviceClass> getAbsAxisUsage(int32_t axis, Flags<InputDeviceClass> deviceClasses) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 303 | // Touch devices get dibs on touch-related axes. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 304 | if (deviceClasses.test(InputDeviceClass::TOUCH)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 305 | switch (axis) { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 306 | case ABS_X: |
| 307 | case ABS_Y: |
| 308 | case ABS_PRESSURE: |
| 309 | case ABS_TOOL_WIDTH: |
| 310 | case ABS_DISTANCE: |
| 311 | case ABS_TILT_X: |
| 312 | case ABS_TILT_Y: |
| 313 | case ABS_MT_SLOT: |
| 314 | case ABS_MT_TOUCH_MAJOR: |
| 315 | case ABS_MT_TOUCH_MINOR: |
| 316 | case ABS_MT_WIDTH_MAJOR: |
| 317 | case ABS_MT_WIDTH_MINOR: |
| 318 | case ABS_MT_ORIENTATION: |
| 319 | case ABS_MT_POSITION_X: |
| 320 | case ABS_MT_POSITION_Y: |
| 321 | case ABS_MT_TOOL_TYPE: |
| 322 | case ABS_MT_BLOB_ID: |
| 323 | case ABS_MT_TRACKING_ID: |
| 324 | case ABS_MT_PRESSURE: |
| 325 | case ABS_MT_DISTANCE: |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 326 | return InputDeviceClass::TOUCH; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 327 | } |
| 328 | } |
| 329 | |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 330 | if (deviceClasses.test(InputDeviceClass::SENSOR)) { |
| 331 | switch (axis) { |
| 332 | case ABS_X: |
| 333 | case ABS_Y: |
| 334 | case ABS_Z: |
| 335 | case ABS_RX: |
| 336 | case ABS_RY: |
| 337 | case ABS_RZ: |
| 338 | return InputDeviceClass::SENSOR; |
| 339 | } |
| 340 | } |
| 341 | |
Michael Wright | 842500e | 2015-03-13 17:32:02 -0700 | [diff] [blame] | 342 | // External stylus gets the pressure axis |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 343 | if (deviceClasses.test(InputDeviceClass::EXTERNAL_STYLUS)) { |
Michael Wright | 842500e | 2015-03-13 17:32:02 -0700 | [diff] [blame] | 344 | if (axis == ABS_PRESSURE) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 345 | return InputDeviceClass::EXTERNAL_STYLUS; |
Michael Wright | 842500e | 2015-03-13 17:32:02 -0700 | [diff] [blame] | 346 | } |
| 347 | } |
| 348 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 349 | // Joystick devices get the rest. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 350 | return deviceClasses & InputDeviceClass::JOYSTICK; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 351 | } |
| 352 | |
| 353 | // --- EventHub::Device --- |
| 354 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 355 | EventHub::Device::Device(int fd, int32_t id, const std::string& path, |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 356 | const InputDeviceIdentifier& identifier) |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 357 | : fd(fd), |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 358 | id(id), |
| 359 | path(path), |
| 360 | identifier(identifier), |
| 361 | classes(0), |
| 362 | configuration(nullptr), |
| 363 | virtualKeyMap(nullptr), |
| 364 | ffEffectPlaying(false), |
| 365 | ffEffectId(-1), |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 366 | associatedDevice(nullptr), |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 367 | controllerNumber(0), |
| 368 | enabled(true), |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 369 | isVirtual(fd < 0) {} |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 370 | |
| 371 | EventHub::Device::~Device() { |
| 372 | close(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | void EventHub::Device::close() { |
| 376 | if (fd >= 0) { |
| 377 | ::close(fd); |
| 378 | fd = -1; |
| 379 | } |
| 380 | } |
| 381 | |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 382 | status_t EventHub::Device::enable() { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 383 | fd = open(path.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 384 | if (fd < 0) { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 385 | ALOGE("could not open %s, %s\n", path.c_str(), strerror(errno)); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 386 | return -errno; |
| 387 | } |
| 388 | enabled = true; |
| 389 | return OK; |
| 390 | } |
| 391 | |
| 392 | status_t EventHub::Device::disable() { |
| 393 | close(); |
| 394 | enabled = false; |
| 395 | return OK; |
| 396 | } |
| 397 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 398 | bool EventHub::Device::hasValidFd() const { |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 399 | return !isVirtual && enabled; |
| 400 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 401 | |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 402 | const std::shared_ptr<KeyCharacterMap> EventHub::Device::getKeyCharacterMap() const { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 403 | return keyMap.keyCharacterMap; |
| 404 | } |
| 405 | |
| 406 | template <std::size_t N> |
| 407 | status_t EventHub::Device::readDeviceBitMask(unsigned long ioctlCode, BitArray<N>& bitArray) { |
| 408 | if (!hasValidFd()) { |
| 409 | return BAD_VALUE; |
| 410 | } |
| 411 | if ((_IOC_SIZE(ioctlCode) == 0)) { |
| 412 | ioctlCode |= _IOC(0, 0, 0, bitArray.bytes()); |
| 413 | } |
| 414 | |
| 415 | typename BitArray<N>::Buffer buffer; |
| 416 | status_t ret = ioctl(fd, ioctlCode, buffer.data()); |
| 417 | bitArray.loadFromBuffer(buffer); |
| 418 | return ret; |
| 419 | } |
| 420 | |
| 421 | void EventHub::Device::configureFd() { |
| 422 | // Set fd parameters with ioctl, such as key repeat, suspend block, and clock type |
| 423 | if (classes.test(InputDeviceClass::KEYBOARD)) { |
| 424 | // Disable kernel key repeat since we handle it ourselves |
| 425 | unsigned int repeatRate[] = {0, 0}; |
| 426 | if (ioctl(fd, EVIOCSREP, repeatRate)) { |
| 427 | ALOGW("Unable to disable kernel key repeat for %s: %s", path.c_str(), strerror(errno)); |
| 428 | } |
| 429 | } |
| 430 | |
| 431 | // Tell the kernel that we want to use the monotonic clock for reporting timestamps |
| 432 | // associated with input events. This is important because the input system |
| 433 | // uses the timestamps extensively and assumes they were recorded using the monotonic |
| 434 | // clock. |
| 435 | int clockId = CLOCK_MONOTONIC; |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 436 | if (classes.test(InputDeviceClass::SENSOR)) { |
| 437 | // Each new sensor event should use the same time base as |
| 438 | // SystemClock.elapsedRealtimeNanos(). |
| 439 | clockId = CLOCK_BOOTTIME; |
| 440 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 441 | bool usingClockIoctl = !ioctl(fd, EVIOCSCLOCKID, &clockId); |
| 442 | ALOGI("usingClockIoctl=%s", toString(usingClockIoctl)); |
| 443 | } |
| 444 | |
| 445 | bool EventHub::Device::hasKeycodeLocked(int keycode) const { |
| 446 | if (!keyMap.haveKeyLayout()) { |
| 447 | return false; |
| 448 | } |
| 449 | |
| 450 | std::vector<int32_t> scanCodes; |
| 451 | keyMap.keyLayoutMap->findScanCodesForKey(keycode, &scanCodes); |
| 452 | const size_t N = scanCodes.size(); |
| 453 | for (size_t i = 0; i < N && i <= KEY_MAX; i++) { |
| 454 | int32_t sc = scanCodes[i]; |
| 455 | if (sc >= 0 && sc <= KEY_MAX && keyBitmask.test(sc)) { |
| 456 | return true; |
| 457 | } |
| 458 | } |
| 459 | |
| 460 | return false; |
| 461 | } |
| 462 | |
| 463 | void EventHub::Device::loadConfigurationLocked() { |
| 464 | configurationFile = |
| 465 | getInputDeviceConfigurationFilePathByDeviceIdentifier(identifier, |
| 466 | InputDeviceConfigurationFileType:: |
| 467 | CONFIGURATION); |
| 468 | if (configurationFile.empty()) { |
| 469 | ALOGD("No input device configuration file found for device '%s'.", identifier.name.c_str()); |
| 470 | } else { |
Siarhei Vishniakou | 4d9f977 | 2020-09-02 22:28:29 -0500 | [diff] [blame] | 471 | android::base::Result<std::unique_ptr<PropertyMap>> propertyMap = |
| 472 | PropertyMap::load(configurationFile.c_str()); |
| 473 | if (!propertyMap.ok()) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 474 | ALOGE("Error loading input device configuration file for device '%s'. " |
| 475 | "Using default configuration.", |
| 476 | identifier.name.c_str()); |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 477 | } else { |
Siarhei Vishniakou | 4d9f977 | 2020-09-02 22:28:29 -0500 | [diff] [blame] | 478 | configuration = std::move(*propertyMap); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 479 | } |
| 480 | } |
| 481 | } |
| 482 | |
| 483 | bool EventHub::Device::loadVirtualKeyMapLocked() { |
| 484 | // The virtual key map is supplied by the kernel as a system board property file. |
| 485 | std::string propPath = "/sys/board_properties/virtualkeys."; |
| 486 | propPath += identifier.getCanonicalName(); |
| 487 | if (access(propPath.c_str(), R_OK)) { |
| 488 | return false; |
| 489 | } |
| 490 | virtualKeyMap = VirtualKeyMap::load(propPath); |
| 491 | return virtualKeyMap != nullptr; |
| 492 | } |
| 493 | |
| 494 | status_t EventHub::Device::loadKeyMapLocked() { |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 495 | return keyMap.load(identifier, configuration.get()); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 496 | } |
| 497 | |
| 498 | bool EventHub::Device::isExternalDeviceLocked() { |
| 499 | if (configuration) { |
| 500 | bool value; |
| 501 | if (configuration->tryGetProperty(String8("device.internal"), value)) { |
| 502 | return !value; |
| 503 | } |
| 504 | } |
| 505 | return identifier.bus == BUS_USB || identifier.bus == BUS_BLUETOOTH; |
| 506 | } |
| 507 | |
| 508 | bool EventHub::Device::deviceHasMicLocked() { |
| 509 | if (configuration) { |
| 510 | bool value; |
| 511 | if (configuration->tryGetProperty(String8("audio.mic"), value)) { |
| 512 | return value; |
| 513 | } |
| 514 | } |
| 515 | return false; |
| 516 | } |
| 517 | |
| 518 | void EventHub::Device::setLedStateLocked(int32_t led, bool on) { |
| 519 | int32_t sc; |
| 520 | if (hasValidFd() && mapLed(led, &sc) != NAME_NOT_FOUND) { |
| 521 | struct input_event ev; |
| 522 | ev.time.tv_sec = 0; |
| 523 | ev.time.tv_usec = 0; |
| 524 | ev.type = EV_LED; |
| 525 | ev.code = sc; |
| 526 | ev.value = on ? 1 : 0; |
| 527 | |
| 528 | ssize_t nWrite; |
| 529 | do { |
| 530 | nWrite = write(fd, &ev, sizeof(struct input_event)); |
| 531 | } while (nWrite == -1 && errno == EINTR); |
| 532 | } |
| 533 | } |
| 534 | |
| 535 | void EventHub::Device::setLedForControllerLocked() { |
| 536 | for (int i = 0; i < MAX_CONTROLLER_LEDS; i++) { |
| 537 | setLedStateLocked(ALED_CONTROLLER_1 + i, controllerNumber == i + 1); |
| 538 | } |
| 539 | } |
| 540 | |
| 541 | status_t EventHub::Device::mapLed(int32_t led, int32_t* outScanCode) const { |
| 542 | if (!keyMap.haveKeyLayout()) { |
| 543 | return NAME_NOT_FOUND; |
| 544 | } |
| 545 | |
| 546 | int32_t scanCode; |
| 547 | if (keyMap.keyLayoutMap->findScanCodeForLed(led, &scanCode) != NAME_NOT_FOUND) { |
| 548 | if (scanCode >= 0 && scanCode <= LED_MAX && ledBitmask.test(scanCode)) { |
| 549 | *outScanCode = scanCode; |
| 550 | return NO_ERROR; |
| 551 | } |
| 552 | } |
| 553 | return NAME_NOT_FOUND; |
| 554 | } |
| 555 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 556 | // Check the sysfs path for any input device batteries, returns true if battery found. |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 557 | bool EventHub::AssociatedDevice::configureBatteryLocked() { |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 558 | nextBatteryId = 0; |
| 559 | // Check if device has any battery. |
| 560 | const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::POWER_SUPPLY); |
| 561 | for (const auto& nodePath : paths) { |
| 562 | RawBatteryInfo info; |
| 563 | info.id = ++nextBatteryId; |
| 564 | info.path = nodePath; |
| 565 | info.name = nodePath.filename(); |
| 566 | |
| 567 | // Scan the path for all the files |
| 568 | // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt |
| 569 | const auto& files = allFilesInPath(nodePath); |
| 570 | for (const auto& file : files) { |
| 571 | const auto it = BATTERY_CLASSES.find(file.filename().string()); |
| 572 | if (it != BATTERY_CLASSES.end()) { |
| 573 | info.flags |= it->second; |
| 574 | } |
| 575 | } |
| 576 | batteryInfos.insert_or_assign(info.id, info); |
| 577 | ALOGD("configureBatteryLocked rawBatteryId %d name %s", info.id, info.name.c_str()); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 578 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 579 | return !batteryInfos.empty(); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 580 | } |
| 581 | |
| 582 | // Check the sysfs path for any input device lights, returns true if lights found. |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 583 | bool EventHub::AssociatedDevice::configureLightsLocked() { |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 584 | nextLightId = 0; |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 585 | // Check if device has any lights. |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 586 | const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::LEDS); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 587 | for (const auto& nodePath : paths) { |
| 588 | RawLightInfo info; |
| 589 | info.id = ++nextLightId; |
| 590 | info.path = nodePath; |
| 591 | info.name = nodePath.filename(); |
| 592 | info.maxBrightness = std::nullopt; |
| 593 | size_t nameStart = info.name.rfind(":"); |
| 594 | if (nameStart != std::string::npos) { |
| 595 | // Trim the name to color name |
| 596 | info.name = info.name.substr(nameStart + 1); |
| 597 | // Set InputLightClass flag for colors |
| 598 | const auto it = LIGHT_CLASSES.find(info.name); |
| 599 | if (it != LIGHT_CLASSES.end()) { |
| 600 | info.flags |= it->second; |
| 601 | } |
| 602 | } |
| 603 | // Scan the path for all the files |
| 604 | // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt |
| 605 | const auto& files = allFilesInPath(nodePath); |
| 606 | for (const auto& file : files) { |
| 607 | const auto it = LIGHT_CLASSES.find(file.filename().string()); |
| 608 | if (it != LIGHT_CLASSES.end()) { |
| 609 | info.flags |= it->second; |
| 610 | // If the node has maximum brightness, read it |
| 611 | if (it->second == InputLightClass::MAX_BRIGHTNESS) { |
| 612 | std::string str; |
| 613 | if (base::ReadFileToString(file, &str)) { |
| 614 | info.maxBrightness = std::stoi(str); |
| 615 | } |
| 616 | } |
| 617 | } |
| 618 | } |
| 619 | lightInfos.insert_or_assign(info.id, info); |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 620 | ALOGD("configureLightsLocked rawLightId %d name %s", info.id, info.name.c_str()); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 621 | } |
| 622 | return !lightInfos.empty(); |
| 623 | } |
| 624 | |
Siarhei Vishniakou | 7a522bf | 2019-09-24 12:46:29 +0100 | [diff] [blame] | 625 | /** |
| 626 | * Get the capabilities for the current process. |
| 627 | * Crashes the system if unable to create / check / destroy the capabilities object. |
| 628 | */ |
| 629 | class Capabilities final { |
| 630 | public: |
| 631 | explicit Capabilities() { |
| 632 | mCaps = cap_get_proc(); |
| 633 | LOG_ALWAYS_FATAL_IF(mCaps == nullptr, "Could not get capabilities of the current process"); |
| 634 | } |
| 635 | |
| 636 | /** |
| 637 | * Check whether the current process has a specific capability |
| 638 | * in the set of effective capabilities. |
| 639 | * Return CAP_SET if the process has the requested capability |
| 640 | * Return CAP_CLEAR otherwise. |
| 641 | */ |
| 642 | cap_flag_value_t checkEffectiveCapability(cap_value_t capability) { |
| 643 | cap_flag_value_t value; |
| 644 | const int result = cap_get_flag(mCaps, capability, CAP_EFFECTIVE, &value); |
| 645 | LOG_ALWAYS_FATAL_IF(result == -1, "Could not obtain the requested capability"); |
| 646 | return value; |
| 647 | } |
| 648 | |
| 649 | ~Capabilities() { |
| 650 | const int result = cap_free(mCaps); |
| 651 | LOG_ALWAYS_FATAL_IF(result == -1, "Could not release the capabilities structure"); |
| 652 | } |
| 653 | |
| 654 | private: |
| 655 | cap_t mCaps; |
| 656 | }; |
| 657 | |
| 658 | static void ensureProcessCanBlockSuspend() { |
| 659 | Capabilities capabilities; |
| 660 | const bool canBlockSuspend = |
| 661 | capabilities.checkEffectiveCapability(CAP_BLOCK_SUSPEND) == CAP_SET; |
| 662 | LOG_ALWAYS_FATAL_IF(!canBlockSuspend, |
| 663 | "Input must be able to block suspend to properly process events"); |
| 664 | } |
| 665 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 666 | // --- EventHub --- |
| 667 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 668 | const int EventHub::EPOLL_MAX_EVENTS; |
| 669 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 670 | EventHub::EventHub(void) |
| 671 | : mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), |
| 672 | mNextDeviceId(1), |
| 673 | mControllerNumbers(), |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 674 | mNeedToSendFinishedDeviceScan(false), |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 675 | mNeedToReopenDevices(false), |
| 676 | mNeedToScanDevices(true), |
| 677 | mPendingEventCount(0), |
| 678 | mPendingEventIndex(0), |
| 679 | mPendingINotify(false) { |
Siarhei Vishniakou | 7a522bf | 2019-09-24 12:46:29 +0100 | [diff] [blame] | 680 | ensureProcessCanBlockSuspend(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 681 | |
Nick Kralevich | fcf1b2b | 2018-12-15 11:59:30 -0800 | [diff] [blame] | 682 | mEpollFd = epoll_create1(EPOLL_CLOEXEC); |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 683 | LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance: %s", strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 684 | |
| 685 | mINotifyFd = inotify_init(); |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 686 | mInputWd = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 687 | LOG_ALWAYS_FATAL_IF(mInputWd < 0, "Could not register INotify for %s: %s", DEVICE_PATH, |
| 688 | strerror(errno)); |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 689 | if (isV4lScanningEnabled()) { |
| 690 | mVideoWd = inotify_add_watch(mINotifyFd, VIDEO_DEVICE_PATH, IN_DELETE | IN_CREATE); |
| 691 | LOG_ALWAYS_FATAL_IF(mVideoWd < 0, "Could not register INotify for %s: %s", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 692 | VIDEO_DEVICE_PATH, strerror(errno)); |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 693 | } else { |
| 694 | mVideoWd = -1; |
| 695 | ALOGI("Video device scanning disabled"); |
| 696 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 697 | |
Siarhei Vishniakou | 2d0e948 | 2019-09-24 12:52:47 +0100 | [diff] [blame] | 698 | struct epoll_event eventItem = {}; |
| 699 | eventItem.events = EPOLLIN | EPOLLWAKEUP; |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 700 | eventItem.data.fd = mINotifyFd; |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 701 | int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 702 | LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno); |
| 703 | |
| 704 | int wakeFds[2]; |
| 705 | result = pipe(wakeFds); |
| 706 | LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno); |
| 707 | |
| 708 | mWakeReadPipeFd = wakeFds[0]; |
| 709 | mWakeWritePipeFd = wakeFds[1]; |
| 710 | |
| 711 | result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK); |
| 712 | LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 713 | errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 714 | |
| 715 | result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK); |
| 716 | LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 717 | errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 718 | |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 719 | eventItem.data.fd = mWakeReadPipeFd; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 720 | result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem); |
| 721 | LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 722 | errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 723 | } |
| 724 | |
| 725 | EventHub::~EventHub(void) { |
| 726 | closeAllDevicesLocked(); |
| 727 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 728 | ::close(mEpollFd); |
| 729 | ::close(mINotifyFd); |
| 730 | ::close(mWakeReadPipeFd); |
| 731 | ::close(mWakeWritePipeFd); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 732 | } |
| 733 | |
| 734 | InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 735 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 736 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 737 | return device != nullptr ? device->identifier : InputDeviceIdentifier(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 738 | } |
| 739 | |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 740 | Flags<InputDeviceClass> EventHub::getDeviceClasses(int32_t deviceId) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 741 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 742 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 743 | return device != nullptr ? device->classes : Flags<InputDeviceClass>(0); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 744 | } |
| 745 | |
| 746 | int32_t EventHub::getDeviceControllerNumber(int32_t deviceId) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 747 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 748 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 749 | return device != nullptr ? device->controllerNumber : 0; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 750 | } |
| 751 | |
| 752 | void EventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 753 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 754 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 755 | if (device != nullptr && device->configuration) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 756 | *outConfiguration = *device->configuration; |
| 757 | } else { |
| 758 | outConfiguration->clear(); |
| 759 | } |
| 760 | } |
| 761 | |
| 762 | status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis, |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 763 | RawAbsoluteAxisInfo* outAxisInfo) const { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 764 | outAxisInfo->clear(); |
| 765 | |
| 766 | if (axis >= 0 && axis <= ABS_MAX) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 767 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 768 | |
| 769 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 770 | if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 771 | struct input_absinfo info; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 772 | if (ioctl(device->fd, EVIOCGABS(axis), &info)) { |
| 773 | ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis, |
| 774 | device->identifier.name.c_str(), device->fd, errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 775 | return -errno; |
| 776 | } |
| 777 | |
| 778 | if (info.minimum != info.maximum) { |
| 779 | outAxisInfo->valid = true; |
| 780 | outAxisInfo->minValue = info.minimum; |
| 781 | outAxisInfo->maxValue = info.maximum; |
| 782 | outAxisInfo->flat = info.flat; |
| 783 | outAxisInfo->fuzz = info.fuzz; |
| 784 | outAxisInfo->resolution = info.resolution; |
| 785 | } |
| 786 | return OK; |
| 787 | } |
| 788 | } |
| 789 | return -1; |
| 790 | } |
| 791 | |
| 792 | bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const { |
| 793 | if (axis >= 0 && axis <= REL_MAX) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 794 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 795 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 796 | return device != nullptr ? device->relBitmask.test(axis) : false; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 797 | } |
| 798 | return false; |
| 799 | } |
| 800 | |
| 801 | bool EventHub::hasInputProperty(int32_t deviceId, int property) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 802 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 803 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 804 | Device* device = getDeviceLocked(deviceId); |
| 805 | return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr |
| 806 | ? device->propBitmask.test(property) |
| 807 | : false; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 808 | } |
| 809 | |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 810 | bool EventHub::hasMscEvent(int32_t deviceId, int mscEvent) const { |
| 811 | std::scoped_lock _l(mLock); |
| 812 | |
| 813 | Device* device = getDeviceLocked(deviceId); |
| 814 | return mscEvent >= 0 && mscEvent <= MSC_MAX && device != nullptr |
| 815 | ? device->mscBitmask.test(mscEvent) |
| 816 | : false; |
| 817 | } |
| 818 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 819 | int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const { |
| 820 | if (scanCode >= 0 && scanCode <= KEY_MAX) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 821 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 822 | |
| 823 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 824 | if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) { |
| 825 | if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) { |
| 826 | return device->keyState.test(scanCode) ? AKEY_STATE_DOWN : AKEY_STATE_UP; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 827 | } |
| 828 | } |
| 829 | } |
| 830 | return AKEY_STATE_UNKNOWN; |
| 831 | } |
| 832 | |
| 833 | int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 834 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 835 | |
| 836 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 837 | if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) { |
Arthur Hung | 7c3ae9c | 2019-03-11 11:23:03 +0800 | [diff] [blame] | 838 | std::vector<int32_t> scanCodes; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 839 | device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes); |
| 840 | if (scanCodes.size() != 0) { |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 841 | if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 842 | for (size_t i = 0; i < scanCodes.size(); i++) { |
Arthur Hung | 7c3ae9c | 2019-03-11 11:23:03 +0800 | [diff] [blame] | 843 | int32_t sc = scanCodes[i]; |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 844 | if (sc >= 0 && sc <= KEY_MAX && device->keyState.test(sc)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 845 | return AKEY_STATE_DOWN; |
| 846 | } |
| 847 | } |
| 848 | return AKEY_STATE_UP; |
| 849 | } |
| 850 | } |
| 851 | } |
| 852 | return AKEY_STATE_UNKNOWN; |
| 853 | } |
| 854 | |
| 855 | int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const { |
| 856 | if (sw >= 0 && sw <= SW_MAX) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 857 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 858 | |
| 859 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 860 | if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) { |
| 861 | if (device->readDeviceBitMask(EVIOCGSW(0), device->swState) >= 0) { |
| 862 | return device->swState.test(sw) ? AKEY_STATE_DOWN : AKEY_STATE_UP; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 863 | } |
| 864 | } |
| 865 | } |
| 866 | return AKEY_STATE_UNKNOWN; |
| 867 | } |
| 868 | |
| 869 | status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const { |
| 870 | *outValue = 0; |
| 871 | |
| 872 | if (axis >= 0 && axis <= ABS_MAX) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 873 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 874 | |
| 875 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 876 | if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 877 | struct input_absinfo info; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 878 | if (ioctl(device->fd, EVIOCGABS(axis), &info)) { |
| 879 | ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis, |
| 880 | device->identifier.name.c_str(), device->fd, errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 881 | return -errno; |
| 882 | } |
| 883 | |
| 884 | *outValue = info.value; |
| 885 | return OK; |
| 886 | } |
| 887 | } |
| 888 | return -1; |
| 889 | } |
| 890 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 891 | bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes, |
| 892 | uint8_t* outFlags) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 893 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 894 | |
| 895 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 896 | if (device != nullptr && device->keyMap.haveKeyLayout()) { |
Arthur Hung | 7c3ae9c | 2019-03-11 11:23:03 +0800 | [diff] [blame] | 897 | std::vector<int32_t> scanCodes; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 898 | for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) { |
| 899 | scanCodes.clear(); |
| 900 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 901 | status_t err = device->keyMap.keyLayoutMap->findScanCodesForKey(keyCodes[codeIndex], |
| 902 | &scanCodes); |
| 903 | if (!err) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 904 | // check the possible scan codes identified by the layout map against the |
| 905 | // map of codes actually emitted by the driver |
| 906 | for (size_t sc = 0; sc < scanCodes.size(); sc++) { |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 907 | if (device->keyBitmask.test(scanCodes[sc])) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 908 | outFlags[codeIndex] = 1; |
| 909 | break; |
| 910 | } |
| 911 | } |
| 912 | } |
| 913 | } |
| 914 | return true; |
| 915 | } |
| 916 | return false; |
| 917 | } |
| 918 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 919 | status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState, |
| 920 | int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 921 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 922 | Device* device = getDeviceLocked(deviceId); |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 923 | status_t status = NAME_NOT_FOUND; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 924 | |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 925 | if (device != nullptr) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 926 | // Check the key character map first. |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 927 | const std::shared_ptr<KeyCharacterMap> kcm = device->getKeyCharacterMap(); |
| 928 | if (kcm) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 929 | if (!kcm->mapKey(scanCode, usageCode, outKeycode)) { |
| 930 | *outFlags = 0; |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 931 | status = NO_ERROR; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 932 | } |
| 933 | } |
| 934 | |
| 935 | // Check the key layout next. |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 936 | if (status != NO_ERROR && device->keyMap.haveKeyLayout()) { |
Siarhei Vishniakou | 592bac2 | 2018-11-08 19:42:38 -0800 | [diff] [blame] | 937 | if (!device->keyMap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags)) { |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 938 | status = NO_ERROR; |
| 939 | } |
| 940 | } |
| 941 | |
| 942 | if (status == NO_ERROR) { |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 943 | if (kcm) { |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 944 | kcm->tryRemapKey(*outKeycode, metaState, outKeycode, outMetaState); |
| 945 | } else { |
| 946 | *outMetaState = metaState; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 947 | } |
| 948 | } |
| 949 | } |
| 950 | |
Dmitry Torokhov | 0faaa0b | 2015-09-24 13:13:55 -0700 | [diff] [blame] | 951 | if (status != NO_ERROR) { |
| 952 | *outKeycode = 0; |
| 953 | *outFlags = 0; |
| 954 | *outMetaState = metaState; |
| 955 | } |
| 956 | |
| 957 | return status; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 958 | } |
| 959 | |
| 960 | status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 961 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 962 | Device* device = getDeviceLocked(deviceId); |
| 963 | |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 964 | if (device != nullptr && device->keyMap.haveKeyLayout()) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 965 | status_t err = device->keyMap.keyLayoutMap->mapAxis(scanCode, outAxisInfo); |
| 966 | if (err == NO_ERROR) { |
| 967 | return NO_ERROR; |
| 968 | } |
| 969 | } |
| 970 | |
| 971 | return NAME_NOT_FOUND; |
| 972 | } |
| 973 | |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 974 | base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId, |
| 975 | int32_t absCode) { |
| 976 | std::scoped_lock _l(mLock); |
| 977 | Device* device = getDeviceLocked(deviceId); |
| 978 | |
| 979 | if (device != nullptr && device->keyMap.haveKeyLayout()) { |
| 980 | return device->keyMap.keyLayoutMap->mapSensor(absCode); |
| 981 | } |
| 982 | return Errorf("Device not found or device has no key layout."); |
| 983 | } |
| 984 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 985 | // Gets the battery info map from battery ID to RawBatteryInfo of the miscellaneous device |
| 986 | // associated with the device ID. Returns an empty map if no miscellaneous device found. |
| 987 | const std::unordered_map<int32_t, RawBatteryInfo>& EventHub::getBatteryInfoLocked( |
| 988 | int32_t deviceId) const { |
| 989 | static const std::unordered_map<int32_t, RawBatteryInfo> EMPTY_BATTERY_INFO = {}; |
| 990 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 991 | if (device == nullptr || !device->associatedDevice) { |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 992 | return EMPTY_BATTERY_INFO; |
| 993 | } |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 994 | return device->associatedDevice->batteryInfos; |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 995 | } |
| 996 | |
| 997 | const std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) { |
| 998 | std::scoped_lock _l(mLock); |
| 999 | std::vector<int32_t> batteryIds; |
| 1000 | |
| 1001 | for (const auto [id, info] : getBatteryInfoLocked(deviceId)) { |
| 1002 | batteryIds.push_back(id); |
| 1003 | } |
| 1004 | |
| 1005 | return batteryIds; |
| 1006 | } |
| 1007 | |
| 1008 | std::optional<RawBatteryInfo> EventHub::getRawBatteryInfo(int32_t deviceId, int32_t batteryId) { |
| 1009 | std::scoped_lock _l(mLock); |
| 1010 | |
| 1011 | const auto infos = getBatteryInfoLocked(deviceId); |
| 1012 | |
| 1013 | auto it = infos.find(batteryId); |
| 1014 | if (it != infos.end()) { |
| 1015 | return it->second; |
| 1016 | } |
| 1017 | |
| 1018 | return std::nullopt; |
| 1019 | } |
| 1020 | |
| 1021 | // Gets the light info map from light ID to RawLightInfo of the miscellaneous device associated |
| 1022 | // with the deivice ID. Returns an empty map if no miscellaneous device found. |
| 1023 | const std::unordered_map<int32_t, RawLightInfo>& EventHub::getLightInfoLocked( |
| 1024 | int32_t deviceId) const { |
| 1025 | static const std::unordered_map<int32_t, RawLightInfo> EMPTY_LIGHT_INFO = {}; |
| 1026 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 1027 | if (device == nullptr || !device->associatedDevice) { |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1028 | return EMPTY_LIGHT_INFO; |
| 1029 | } |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 1030 | return device->associatedDevice->lightInfos; |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1031 | } |
| 1032 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1033 | const std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) { |
| 1034 | std::scoped_lock _l(mLock); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1035 | std::vector<int32_t> lightIds; |
| 1036 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1037 | for (const auto [id, info] : getLightInfoLocked(deviceId)) { |
| 1038 | lightIds.push_back(id); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1039 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1040 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1041 | return lightIds; |
| 1042 | } |
| 1043 | |
| 1044 | std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) { |
| 1045 | std::scoped_lock _l(mLock); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1046 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1047 | const auto infos = getLightInfoLocked(deviceId); |
| 1048 | |
| 1049 | auto it = infos.find(lightId); |
| 1050 | if (it != infos.end()) { |
| 1051 | return it->second; |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1052 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1053 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1054 | return std::nullopt; |
| 1055 | } |
| 1056 | |
| 1057 | std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t lightId) { |
| 1058 | std::scoped_lock _l(mLock); |
| 1059 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1060 | const auto infos = getLightInfoLocked(deviceId); |
| 1061 | auto it = infos.find(lightId); |
| 1062 | if (it == infos.end()) { |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1063 | return std::nullopt; |
| 1064 | } |
| 1065 | std::string buffer; |
| 1066 | if (!base::ReadFileToString(it->second.path / LIGHT_NODES.at(InputLightClass::BRIGHTNESS), |
| 1067 | &buffer)) { |
| 1068 | return std::nullopt; |
| 1069 | } |
| 1070 | return std::stoi(buffer); |
| 1071 | } |
| 1072 | |
| 1073 | std::optional<std::unordered_map<LightColor, int32_t>> EventHub::getLightIntensities( |
| 1074 | int32_t deviceId, int32_t lightId) { |
| 1075 | std::scoped_lock _l(mLock); |
| 1076 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1077 | const auto infos = getLightInfoLocked(deviceId); |
| 1078 | auto lightIt = infos.find(lightId); |
| 1079 | if (lightIt == infos.end()) { |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1080 | return std::nullopt; |
| 1081 | } |
| 1082 | |
| 1083 | auto ret = |
| 1084 | getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX)); |
| 1085 | |
| 1086 | if (!ret.has_value()) { |
| 1087 | return std::nullopt; |
| 1088 | } |
| 1089 | std::array<LightColor, COLOR_NUM> colors = ret.value(); |
| 1090 | |
| 1091 | std::string intensityStr; |
| 1092 | if (!base::ReadFileToString(lightIt->second.path / |
| 1093 | LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY), |
| 1094 | &intensityStr)) { |
| 1095 | return std::nullopt; |
| 1096 | } |
| 1097 | |
| 1098 | // Intensity node outputs 3 color values |
| 1099 | std::regex intensityPattern("([0-9]+)\\s([0-9]+)\\s([0-9]+)[\\n]"); |
| 1100 | std::smatch results; |
| 1101 | |
| 1102 | if (!std::regex_match(intensityStr, results, intensityPattern)) { |
| 1103 | return std::nullopt; |
| 1104 | } |
| 1105 | std::unordered_map<LightColor, int32_t> intensities; |
| 1106 | for (size_t i = 1; i < results.size(); i++) { |
| 1107 | int value = std::stoi(results[i].str()); |
| 1108 | intensities.emplace(colors[i - 1], value); |
| 1109 | } |
| 1110 | return intensities; |
| 1111 | } |
| 1112 | |
| 1113 | void EventHub::setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) { |
| 1114 | std::scoped_lock _l(mLock); |
| 1115 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1116 | const auto infos = getLightInfoLocked(deviceId); |
| 1117 | auto lightIt = infos.find(lightId); |
| 1118 | if (lightIt == infos.end()) { |
| 1119 | ALOGE("%s lightId %d not found ", __func__, lightId); |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1120 | return; |
| 1121 | } |
| 1122 | |
| 1123 | if (!base::WriteStringToFile(std::to_string(brightness), |
| 1124 | lightIt->second.path / |
| 1125 | LIGHT_NODES.at(InputLightClass::BRIGHTNESS))) { |
| 1126 | ALOGE("Can not write to file, error: %s", strerror(errno)); |
| 1127 | } |
| 1128 | } |
| 1129 | |
| 1130 | void EventHub::setLightIntensities(int32_t deviceId, int32_t lightId, |
| 1131 | std::unordered_map<LightColor, int32_t> intensities) { |
| 1132 | std::scoped_lock _l(mLock); |
| 1133 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1134 | const auto infos = getLightInfoLocked(deviceId); |
| 1135 | auto lightIt = infos.find(lightId); |
| 1136 | if (lightIt == infos.end()) { |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1137 | ALOGE("Light Id %d does not exist.", lightId); |
| 1138 | return; |
| 1139 | } |
| 1140 | |
| 1141 | auto ret = |
| 1142 | getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX)); |
| 1143 | |
| 1144 | if (!ret.has_value()) { |
| 1145 | return; |
| 1146 | } |
| 1147 | std::array<LightColor, COLOR_NUM> colors = ret.value(); |
| 1148 | |
| 1149 | std::string rgbStr; |
| 1150 | for (size_t i = 0; i < COLOR_NUM; i++) { |
| 1151 | auto it = intensities.find(colors[i]); |
| 1152 | if (it != intensities.end()) { |
| 1153 | rgbStr += std::to_string(it->second); |
| 1154 | // Insert space between colors |
| 1155 | if (i < COLOR_NUM - 1) { |
| 1156 | rgbStr += " "; |
| 1157 | } |
| 1158 | } |
| 1159 | } |
| 1160 | // Append new line |
| 1161 | rgbStr += "\n"; |
| 1162 | |
| 1163 | if (!base::WriteStringToFile(rgbStr, |
| 1164 | lightIt->second.path / |
| 1165 | LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY))) { |
| 1166 | ALOGE("Can not write to file, error: %s", strerror(errno)); |
| 1167 | } |
| 1168 | } |
| 1169 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1170 | void EventHub::setExcludedDevices(const std::vector<std::string>& devices) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1171 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1172 | |
| 1173 | mExcludedDevices = devices; |
| 1174 | } |
| 1175 | |
| 1176 | bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1177 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1178 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1179 | if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) { |
| 1180 | return device->keyBitmask.test(scanCode); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1181 | } |
| 1182 | return false; |
| 1183 | } |
| 1184 | |
| 1185 | bool EventHub::hasLed(int32_t deviceId, int32_t led) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1186 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1187 | Device* device = getDeviceLocked(deviceId); |
| 1188 | int32_t sc; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1189 | if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) { |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1190 | return device->ledBitmask.test(sc); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1191 | } |
| 1192 | return false; |
| 1193 | } |
| 1194 | |
| 1195 | void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1196 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1197 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1198 | if (device != nullptr && device->hasValidFd()) { |
| 1199 | device->setLedStateLocked(led, on); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1200 | } |
| 1201 | } |
| 1202 | |
| 1203 | void EventHub::getVirtualKeyDefinitions(int32_t deviceId, |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1204 | std::vector<VirtualKeyDefinition>& outVirtualKeys) const { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1205 | outVirtualKeys.clear(); |
| 1206 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1207 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1208 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1209 | if (device != nullptr && device->virtualKeyMap) { |
Arthur Hung | 7c3ae9c | 2019-03-11 11:23:03 +0800 | [diff] [blame] | 1210 | const std::vector<VirtualKeyDefinition> virtualKeys = |
| 1211 | device->virtualKeyMap->getVirtualKeys(); |
| 1212 | outVirtualKeys.insert(outVirtualKeys.end(), virtualKeys.begin(), virtualKeys.end()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1213 | } |
| 1214 | } |
| 1215 | |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 1216 | const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1217 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1218 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1219 | if (device != nullptr) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1220 | return device->getKeyCharacterMap(); |
| 1221 | } |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 1222 | return nullptr; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1223 | } |
| 1224 | |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 1225 | bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId, std::shared_ptr<KeyCharacterMap> map) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1226 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1227 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 1228 | if (device != nullptr && map != nullptr && device->keyMap.keyCharacterMap != nullptr) { |
| 1229 | device->keyMap.keyCharacterMap->combine(*map); |
| 1230 | device->keyMap.keyCharacterMapFile = device->keyMap.keyCharacterMap->getLoadFileName(); |
| 1231 | return true; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1232 | } |
| 1233 | return false; |
| 1234 | } |
| 1235 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1236 | static std::string generateDescriptor(InputDeviceIdentifier& identifier) { |
| 1237 | std::string rawDescriptor; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1238 | rawDescriptor += StringPrintf(":%04x:%04x:", identifier.vendor, identifier.product); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1239 | // TODO add handling for USB devices to not uniqueify kbs that show up twice |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1240 | if (!identifier.uniqueId.empty()) { |
| 1241 | rawDescriptor += "uniqueId:"; |
| 1242 | rawDescriptor += identifier.uniqueId; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1243 | } else if (identifier.nonce != 0) { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1244 | rawDescriptor += StringPrintf("nonce:%04x", identifier.nonce); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1245 | } |
| 1246 | |
| 1247 | if (identifier.vendor == 0 && identifier.product == 0) { |
| 1248 | // If we don't know the vendor and product id, then the device is probably |
| 1249 | // built-in so we need to rely on other information to uniquely identify |
| 1250 | // the input device. Usually we try to avoid relying on the device name or |
| 1251 | // location but for built-in input device, they are unlikely to ever change. |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1252 | if (!identifier.name.empty()) { |
| 1253 | rawDescriptor += "name:"; |
| 1254 | rawDescriptor += identifier.name; |
| 1255 | } else if (!identifier.location.empty()) { |
| 1256 | rawDescriptor += "location:"; |
| 1257 | rawDescriptor += identifier.location; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1258 | } |
| 1259 | } |
| 1260 | identifier.descriptor = sha1(rawDescriptor); |
| 1261 | return rawDescriptor; |
| 1262 | } |
| 1263 | |
| 1264 | void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) { |
| 1265 | // Compute a device descriptor that uniquely identifies the device. |
| 1266 | // The descriptor is assumed to be a stable identifier. Its value should not |
| 1267 | // change between reboots, reconnections, firmware updates or new releases |
| 1268 | // of Android. In practice we sometimes get devices that cannot be uniquely |
| 1269 | // identified. In this case we enforce uniqueness between connected devices. |
| 1270 | // Ideally, we also want the descriptor to be short and relatively opaque. |
| 1271 | |
| 1272 | identifier.nonce = 0; |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1273 | std::string rawDescriptor = generateDescriptor(identifier); |
| 1274 | if (identifier.uniqueId.empty()) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1275 | // If it didn't have a unique id check for conflicts and enforce |
| 1276 | // uniqueness if necessary. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1277 | while (getDeviceByDescriptorLocked(identifier.descriptor) != nullptr) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1278 | identifier.nonce++; |
| 1279 | rawDescriptor = generateDescriptor(identifier); |
| 1280 | } |
| 1281 | } |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1282 | ALOGV("Created descriptor: raw=%s, cooked=%s", rawDescriptor.c_str(), |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1283 | identifier.descriptor.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1284 | } |
| 1285 | |
Nathaniel R. Lewis | cacd69a | 2019-08-12 22:07:00 +0000 | [diff] [blame] | 1286 | void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1287 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1288 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1289 | if (device != nullptr && device->hasValidFd()) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1290 | ff_effect effect; |
| 1291 | memset(&effect, 0, sizeof(effect)); |
| 1292 | effect.type = FF_RUMBLE; |
| 1293 | effect.id = device->ffEffectId; |
Nathaniel R. Lewis | cacd69a | 2019-08-12 22:07:00 +0000 | [diff] [blame] | 1294 | // evdev FF_RUMBLE effect only supports two channels of vibration. |
Chris Ye | 6393a26 | 2020-08-04 19:41:36 -0700 | [diff] [blame] | 1295 | effect.u.rumble.strong_magnitude = element.getMagnitude(FF_STRONG_MAGNITUDE_CHANNEL_IDX); |
| 1296 | effect.u.rumble.weak_magnitude = element.getMagnitude(FF_WEAK_MAGNITUDE_CHANNEL_IDX); |
Nathaniel R. Lewis | cacd69a | 2019-08-12 22:07:00 +0000 | [diff] [blame] | 1297 | effect.replay.length = element.duration.count(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1298 | effect.replay.delay = 0; |
| 1299 | if (ioctl(device->fd, EVIOCSFF, &effect)) { |
| 1300 | ALOGW("Could not upload force feedback effect to device %s due to error %d.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1301 | device->identifier.name.c_str(), errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1302 | return; |
| 1303 | } |
| 1304 | device->ffEffectId = effect.id; |
| 1305 | |
| 1306 | struct input_event ev; |
| 1307 | ev.time.tv_sec = 0; |
| 1308 | ev.time.tv_usec = 0; |
| 1309 | ev.type = EV_FF; |
| 1310 | ev.code = device->ffEffectId; |
| 1311 | ev.value = 1; |
| 1312 | if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) { |
| 1313 | ALOGW("Could not start force feedback effect on device %s due to error %d.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1314 | device->identifier.name.c_str(), errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1315 | return; |
| 1316 | } |
| 1317 | device->ffEffectPlaying = true; |
| 1318 | } |
| 1319 | } |
| 1320 | |
| 1321 | void EventHub::cancelVibrate(int32_t deviceId) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1322 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1323 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1324 | if (device != nullptr && device->hasValidFd()) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1325 | if (device->ffEffectPlaying) { |
| 1326 | device->ffEffectPlaying = false; |
| 1327 | |
| 1328 | struct input_event ev; |
| 1329 | ev.time.tv_sec = 0; |
| 1330 | ev.time.tv_usec = 0; |
| 1331 | ev.type = EV_FF; |
| 1332 | ev.code = device->ffEffectId; |
| 1333 | ev.value = 0; |
| 1334 | if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) { |
| 1335 | ALOGW("Could not stop force feedback effect on device %s due to error %d.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1336 | device->identifier.name.c_str(), errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1337 | return; |
| 1338 | } |
| 1339 | } |
| 1340 | } |
| 1341 | } |
| 1342 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1343 | std::vector<int32_t> EventHub::getVibratorIds(int32_t deviceId) { |
| 1344 | std::scoped_lock _l(mLock); |
| 1345 | std::vector<int32_t> vibrators; |
| 1346 | Device* device = getDeviceLocked(deviceId); |
| 1347 | if (device != nullptr && device->hasValidFd() && |
| 1348 | device->classes.test(InputDeviceClass::VIBRATOR)) { |
| 1349 | vibrators.push_back(FF_STRONG_MAGNITUDE_CHANNEL_IDX); |
| 1350 | vibrators.push_back(FF_WEAK_MAGNITUDE_CHANNEL_IDX); |
| 1351 | } |
| 1352 | return vibrators; |
| 1353 | } |
| 1354 | |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1355 | EventHub::Device* EventHub::getDeviceByDescriptorLocked(const std::string& descriptor) const { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1356 | for (const auto& [id, device] : mDevices) { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1357 | if (descriptor == device->identifier.descriptor) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1358 | return device.get(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1359 | } |
| 1360 | } |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 1361 | return nullptr; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1362 | } |
| 1363 | |
| 1364 | EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const { |
Prabir Pradhan | cae4b3a | 2019-02-05 18:51:32 -0800 | [diff] [blame] | 1365 | if (deviceId == ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1366 | deviceId = mBuiltInKeyboardId; |
| 1367 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1368 | const auto& it = mDevices.find(deviceId); |
| 1369 | return it != mDevices.end() ? it->second.get() : nullptr; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1370 | } |
| 1371 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1372 | EventHub::Device* EventHub::getDeviceByPathLocked(const std::string& devicePath) const { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1373 | for (const auto& [id, device] : mDevices) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1374 | if (device->path == devicePath) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1375 | return device.get(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1376 | } |
| 1377 | } |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 1378 | return nullptr; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1379 | } |
| 1380 | |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1381 | /** |
| 1382 | * The file descriptor could be either input device, or a video device (associated with a |
| 1383 | * specific input device). Check both cases here, and return the device that this event |
| 1384 | * belongs to. Caller can compare the fd's once more to determine event type. |
| 1385 | * Looks through all input devices, and only attached video devices. Unattached video |
| 1386 | * devices are ignored. |
| 1387 | */ |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1388 | EventHub::Device* EventHub::getDeviceByFdLocked(int fd) const { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1389 | for (const auto& [id, device] : mDevices) { |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1390 | if (device->fd == fd) { |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1391 | // This is an input device event |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1392 | return device.get(); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1393 | } |
| 1394 | if (device->videoDevice && device->videoDevice->getFd() == fd) { |
| 1395 | // This is a video device event |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1396 | return device.get(); |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1397 | } |
| 1398 | } |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1399 | // We do not check mUnattachedVideoDevices here because they should not participate in epoll, |
| 1400 | // and therefore should never be looked up by fd. |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1401 | return nullptr; |
| 1402 | } |
| 1403 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1404 | std::optional<int32_t> EventHub::getBatteryCapacity(int32_t deviceId, int32_t batteryId) const { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1405 | std::scoped_lock _l(mLock); |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1406 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1407 | const auto infos = getBatteryInfoLocked(deviceId); |
| 1408 | auto it = infos.find(batteryId); |
| 1409 | if (it == infos.end()) { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1410 | return std::nullopt; |
| 1411 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1412 | std::string buffer; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1413 | |
| 1414 | // Some devices report battery capacity as an integer through the "capacity" file |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1415 | if (base::ReadFileToString(it->second.path / BATTERY_NODES.at(InputBatteryClass::CAPACITY), |
| 1416 | &buffer)) { |
Chris Ye | d193677 | 2021-02-22 10:30:40 -0800 | [diff] [blame] | 1417 | return std::stoi(base::Trim(buffer)); |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1418 | } |
| 1419 | |
| 1420 | // Other devices report capacity as an enum value POWER_SUPPLY_CAPACITY_LEVEL_XXX |
| 1421 | // These values are taken from kernel source code include/linux/power_supply.h |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1422 | if (base::ReadFileToString(it->second.path / |
| 1423 | BATTERY_NODES.at(InputBatteryClass::CAPACITY_LEVEL), |
| 1424 | &buffer)) { |
Chris Ye | d193677 | 2021-02-22 10:30:40 -0800 | [diff] [blame] | 1425 | // Remove any white space such as trailing new line |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1426 | const auto levelIt = BATTERY_LEVEL.find(base::Trim(buffer)); |
| 1427 | if (levelIt != BATTERY_LEVEL.end()) { |
| 1428 | return levelIt->second; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1429 | } |
| 1430 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1431 | |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1432 | return std::nullopt; |
| 1433 | } |
| 1434 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1435 | std::optional<int32_t> EventHub::getBatteryStatus(int32_t deviceId, int32_t batteryId) const { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1436 | std::scoped_lock _l(mLock); |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1437 | const auto infos = getBatteryInfoLocked(deviceId); |
| 1438 | auto it = infos.find(batteryId); |
| 1439 | if (it == infos.end()) { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1440 | return std::nullopt; |
| 1441 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1442 | std::string buffer; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1443 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1444 | if (!base::ReadFileToString(it->second.path / BATTERY_NODES.at(InputBatteryClass::STATUS), |
| 1445 | &buffer)) { |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1446 | ALOGE("Failed to read sysfs battery info: %s", strerror(errno)); |
| 1447 | return std::nullopt; |
| 1448 | } |
| 1449 | |
Chris Ye | d193677 | 2021-02-22 10:30:40 -0800 | [diff] [blame] | 1450 | // Remove white space like trailing new line |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1451 | const auto statusIt = BATTERY_STATUS.find(base::Trim(buffer)); |
| 1452 | if (statusIt != BATTERY_STATUS.end()) { |
| 1453 | return statusIt->second; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 1454 | } |
| 1455 | |
| 1456 | return std::nullopt; |
| 1457 | } |
| 1458 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1459 | size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) { |
| 1460 | ALOG_ASSERT(bufferSize >= 1); |
| 1461 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1462 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1463 | |
| 1464 | struct input_event readBuffer[bufferSize]; |
| 1465 | |
| 1466 | RawEvent* event = buffer; |
| 1467 | size_t capacity = bufferSize; |
| 1468 | bool awoken = false; |
| 1469 | for (;;) { |
| 1470 | nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| 1471 | |
| 1472 | // Reopen input devices if needed. |
| 1473 | if (mNeedToReopenDevices) { |
| 1474 | mNeedToReopenDevices = false; |
| 1475 | |
| 1476 | ALOGI("Reopening all input devices due to a configuration change."); |
| 1477 | |
| 1478 | closeAllDevicesLocked(); |
| 1479 | mNeedToScanDevices = true; |
| 1480 | break; // return to the caller before we actually rescan |
| 1481 | } |
| 1482 | |
| 1483 | // Report any devices that had last been added/removed. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1484 | for (auto it = mClosingDevices.begin(); it != mClosingDevices.end();) { |
| 1485 | std::unique_ptr<Device> device = std::move(*it); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1486 | ALOGV("Reporting device closed: id=%d, name=%s\n", device->id, device->path.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1487 | event->when = now; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1488 | event->deviceId = (device->id == mBuiltInKeyboardId) |
| 1489 | ? ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID |
| 1490 | : device->id; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1491 | event->type = DEVICE_REMOVED; |
| 1492 | event += 1; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1493 | it = mClosingDevices.erase(it); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1494 | mNeedToSendFinishedDeviceScan = true; |
| 1495 | if (--capacity == 0) { |
| 1496 | break; |
| 1497 | } |
| 1498 | } |
| 1499 | |
| 1500 | if (mNeedToScanDevices) { |
| 1501 | mNeedToScanDevices = false; |
| 1502 | scanDevicesLocked(); |
| 1503 | mNeedToSendFinishedDeviceScan = true; |
| 1504 | } |
| 1505 | |
Siarhei Vishniakou | f49608d | 2020-08-20 19:18:21 -0500 | [diff] [blame] | 1506 | while (!mOpeningDevices.empty()) { |
| 1507 | std::unique_ptr<Device> device = std::move(*mOpeningDevices.rbegin()); |
| 1508 | mOpeningDevices.pop_back(); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1509 | ALOGV("Reporting device opened: id=%d, name=%s\n", device->id, device->path.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1510 | event->when = now; |
| 1511 | event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id; |
| 1512 | event->type = DEVICE_ADDED; |
| 1513 | event += 1; |
Siarhei Vishniakou | f49608d | 2020-08-20 19:18:21 -0500 | [diff] [blame] | 1514 | |
| 1515 | // Try to find a matching video device by comparing device names |
| 1516 | for (auto it = mUnattachedVideoDevices.begin(); it != mUnattachedVideoDevices.end(); |
| 1517 | it++) { |
| 1518 | std::unique_ptr<TouchVideoDevice>& videoDevice = *it; |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 1519 | if (tryAddVideoDeviceLocked(*device, videoDevice)) { |
Siarhei Vishniakou | f49608d | 2020-08-20 19:18:21 -0500 | [diff] [blame] | 1520 | // videoDevice was transferred to 'device' |
| 1521 | it = mUnattachedVideoDevices.erase(it); |
| 1522 | break; |
| 1523 | } |
| 1524 | } |
| 1525 | |
| 1526 | auto [dev_it, inserted] = mDevices.insert_or_assign(device->id, std::move(device)); |
| 1527 | if (!inserted) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1528 | ALOGW("Device id %d exists, replaced.", device->id); |
| 1529 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1530 | mNeedToSendFinishedDeviceScan = true; |
| 1531 | if (--capacity == 0) { |
| 1532 | break; |
| 1533 | } |
| 1534 | } |
| 1535 | |
| 1536 | if (mNeedToSendFinishedDeviceScan) { |
| 1537 | mNeedToSendFinishedDeviceScan = false; |
| 1538 | event->when = now; |
| 1539 | event->type = FINISHED_DEVICE_SCAN; |
| 1540 | event += 1; |
| 1541 | if (--capacity == 0) { |
| 1542 | break; |
| 1543 | } |
| 1544 | } |
| 1545 | |
| 1546 | // Grab the next input event. |
| 1547 | bool deviceChanged = false; |
| 1548 | while (mPendingEventIndex < mPendingEventCount) { |
| 1549 | const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++]; |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1550 | if (eventItem.data.fd == mINotifyFd) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1551 | if (eventItem.events & EPOLLIN) { |
| 1552 | mPendingINotify = true; |
| 1553 | } else { |
| 1554 | ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events); |
| 1555 | } |
| 1556 | continue; |
| 1557 | } |
| 1558 | |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1559 | if (eventItem.data.fd == mWakeReadPipeFd) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1560 | if (eventItem.events & EPOLLIN) { |
| 1561 | ALOGV("awoken after wake()"); |
| 1562 | awoken = true; |
Siarhei Vishniakou | b4d960d | 2019-10-03 15:38:44 -0500 | [diff] [blame] | 1563 | char wakeReadBuffer[16]; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1564 | ssize_t nRead; |
| 1565 | do { |
Siarhei Vishniakou | b4d960d | 2019-10-03 15:38:44 -0500 | [diff] [blame] | 1566 | nRead = read(mWakeReadPipeFd, wakeReadBuffer, sizeof(wakeReadBuffer)); |
| 1567 | } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(wakeReadBuffer)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1568 | } else { |
| 1569 | ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1570 | eventItem.events); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1571 | } |
| 1572 | continue; |
| 1573 | } |
| 1574 | |
Siarhei Vishniakou | 4bc561c | 2018-11-02 17:41:58 -0700 | [diff] [blame] | 1575 | Device* device = getDeviceByFdLocked(eventItem.data.fd); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1576 | if (device == nullptr) { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1577 | ALOGE("Received unexpected epoll event 0x%08x for unknown fd %d.", eventItem.events, |
| 1578 | eventItem.data.fd); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1579 | ALOG_ASSERT(!DEBUG); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1580 | continue; |
| 1581 | } |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1582 | if (device->videoDevice && eventItem.data.fd == device->videoDevice->getFd()) { |
| 1583 | if (eventItem.events & EPOLLIN) { |
| 1584 | size_t numFrames = device->videoDevice->readAndQueueFrames(); |
| 1585 | if (numFrames == 0) { |
| 1586 | ALOGE("Received epoll event for video device %s, but could not read frame", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1587 | device->videoDevice->getName().c_str()); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1588 | } |
| 1589 | } else if (eventItem.events & EPOLLHUP) { |
| 1590 | // TODO(b/121395353) - consider adding EPOLLRDHUP |
| 1591 | ALOGI("Removing video device %s due to epoll hang-up event.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1592 | device->videoDevice->getName().c_str()); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1593 | unregisterVideoDeviceFromEpollLocked(*device->videoDevice); |
| 1594 | device->videoDevice = nullptr; |
| 1595 | } else { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1596 | ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events, |
| 1597 | device->videoDevice->getName().c_str()); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1598 | ALOG_ASSERT(!DEBUG); |
| 1599 | } |
| 1600 | continue; |
| 1601 | } |
| 1602 | // This must be an input event |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1603 | if (eventItem.events & EPOLLIN) { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1604 | int32_t readSize = |
| 1605 | read(device->fd, readBuffer, sizeof(struct input_event) * capacity); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1606 | if (readSize == 0 || (readSize < 0 && errno == ENODEV)) { |
| 1607 | // Device was removed before INotify noticed. |
Mark Salyzyn | 5aa26b2 | 2014-06-10 13:07:44 -0700 | [diff] [blame] | 1608 | ALOGW("could not get event, removed? (fd: %d size: %" PRId32 |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1609 | " bufferSize: %zu capacity: %zu errno: %d)\n", |
| 1610 | device->fd, readSize, bufferSize, capacity, errno); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1611 | deviceChanged = true; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1612 | closeDeviceLocked(*device); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1613 | } else if (readSize < 0) { |
| 1614 | if (errno != EAGAIN && errno != EINTR) { |
| 1615 | ALOGW("could not get event (errno=%d)", errno); |
| 1616 | } |
| 1617 | } else if ((readSize % sizeof(struct input_event)) != 0) { |
| 1618 | ALOGE("could not get event (wrong size: %d)", readSize); |
| 1619 | } else { |
| 1620 | int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id; |
| 1621 | |
| 1622 | size_t count = size_t(readSize) / sizeof(struct input_event); |
| 1623 | for (size_t i = 0; i < count; i++) { |
| 1624 | struct input_event& iev = readBuffer[i]; |
Siarhei Vishniakou | 592bac2 | 2018-11-08 19:42:38 -0800 | [diff] [blame] | 1625 | event->when = processEventTimestamp(iev); |
Siarhei Vishniakou | 58ba3d1 | 2021-02-11 01:31:07 +0000 | [diff] [blame] | 1626 | event->readTime = systemTime(SYSTEM_TIME_MONOTONIC); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1627 | event->deviceId = deviceId; |
| 1628 | event->type = iev.type; |
| 1629 | event->code = iev.code; |
| 1630 | event->value = iev.value; |
| 1631 | event += 1; |
| 1632 | capacity -= 1; |
| 1633 | } |
| 1634 | if (capacity == 0) { |
| 1635 | // The result buffer is full. Reset the pending event index |
| 1636 | // so we will try to read the device again on the next iteration. |
| 1637 | mPendingEventIndex -= 1; |
| 1638 | break; |
| 1639 | } |
| 1640 | } |
| 1641 | } else if (eventItem.events & EPOLLHUP) { |
| 1642 | ALOGI("Removing device %s due to epoll hang-up event.", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1643 | device->identifier.name.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1644 | deviceChanged = true; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1645 | closeDeviceLocked(*device); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1646 | } else { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1647 | ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events, |
| 1648 | device->identifier.name.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1649 | } |
| 1650 | } |
| 1651 | |
| 1652 | // readNotify() will modify the list of devices so this must be done after |
| 1653 | // processing all other events to ensure that we read all remaining events |
| 1654 | // before closing the devices. |
| 1655 | if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) { |
| 1656 | mPendingINotify = false; |
| 1657 | readNotifyLocked(); |
| 1658 | deviceChanged = true; |
| 1659 | } |
| 1660 | |
| 1661 | // Report added or removed devices immediately. |
| 1662 | if (deviceChanged) { |
| 1663 | continue; |
| 1664 | } |
| 1665 | |
| 1666 | // Return now if we have collected any events or if we were explicitly awoken. |
| 1667 | if (event != buffer || awoken) { |
| 1668 | break; |
| 1669 | } |
| 1670 | |
Siarhei Vishniakou | 4b5a87f | 2019-09-24 13:03:58 +0100 | [diff] [blame] | 1671 | // Poll for events. |
| 1672 | // When a device driver has pending (unread) events, it acquires |
| 1673 | // a kernel wake lock. Once the last pending event has been read, the device |
| 1674 | // driver will release the kernel wake lock, but the epoll will hold the wakelock, |
| 1675 | // since we are using EPOLLWAKEUP. The wakelock is released by the epoll when epoll_wait |
| 1676 | // is called again for the same fd that produced the event. |
| 1677 | // Thus the system can only sleep if there are no events pending or |
| 1678 | // currently being processed. |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1679 | // |
| 1680 | // The timeout is advisory only. If the device is asleep, it will not wake just to |
| 1681 | // service the timeout. |
| 1682 | mPendingEventIndex = 0; |
| 1683 | |
Siarhei Vishniakou | 4b5a87f | 2019-09-24 13:03:58 +0100 | [diff] [blame] | 1684 | mLock.unlock(); // release lock before poll |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1685 | |
| 1686 | int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis); |
| 1687 | |
Siarhei Vishniakou | 4b5a87f | 2019-09-24 13:03:58 +0100 | [diff] [blame] | 1688 | mLock.lock(); // reacquire lock after poll |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1689 | |
| 1690 | if (pollResult == 0) { |
| 1691 | // Timed out. |
| 1692 | mPendingEventCount = 0; |
| 1693 | break; |
| 1694 | } |
| 1695 | |
| 1696 | if (pollResult < 0) { |
| 1697 | // An error occurred. |
| 1698 | mPendingEventCount = 0; |
| 1699 | |
| 1700 | // Sleep after errors to avoid locking up the system. |
| 1701 | // Hopefully the error is transient. |
| 1702 | if (errno != EINTR) { |
| 1703 | ALOGW("poll failed (errno=%d)\n", errno); |
| 1704 | usleep(100000); |
| 1705 | } |
| 1706 | } else { |
| 1707 | // Some events occurred. |
| 1708 | mPendingEventCount = size_t(pollResult); |
| 1709 | } |
| 1710 | } |
| 1711 | |
| 1712 | // All done, return the number of events we read. |
| 1713 | return event - buffer; |
| 1714 | } |
| 1715 | |
Siarhei Vishniakou | add8929 | 2018-12-13 19:23:36 -0800 | [diff] [blame] | 1716 | std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 1717 | std::scoped_lock _l(mLock); |
Siarhei Vishniakou | add8929 | 2018-12-13 19:23:36 -0800 | [diff] [blame] | 1718 | |
| 1719 | Device* device = getDeviceLocked(deviceId); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1720 | if (device == nullptr || !device->videoDevice) { |
Siarhei Vishniakou | add8929 | 2018-12-13 19:23:36 -0800 | [diff] [blame] | 1721 | return {}; |
| 1722 | } |
| 1723 | return device->videoDevice->consumeFrames(); |
| 1724 | } |
| 1725 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1726 | void EventHub::wake() { |
| 1727 | ALOGV("wake() called"); |
| 1728 | |
| 1729 | ssize_t nWrite; |
| 1730 | do { |
| 1731 | nWrite = write(mWakeWritePipeFd, "W", 1); |
| 1732 | } while (nWrite == -1 && errno == EINTR); |
| 1733 | |
| 1734 | if (nWrite != 1 && errno != EAGAIN) { |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 1735 | ALOGW("Could not write wake signal: %s", strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1736 | } |
| 1737 | } |
| 1738 | |
| 1739 | void EventHub::scanDevicesLocked() { |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 1740 | status_t result = scanDirLocked(DEVICE_PATH); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1741 | if (result < 0) { |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 1742 | ALOGE("scan dir failed for %s", DEVICE_PATH); |
| 1743 | } |
Philip Quinn | 39b8168 | 2019-01-09 22:20:39 -0800 | [diff] [blame] | 1744 | if (isV4lScanningEnabled()) { |
| 1745 | result = scanVideoDirLocked(VIDEO_DEVICE_PATH); |
| 1746 | if (result != OK) { |
| 1747 | ALOGE("scan video dir failed for %s", VIDEO_DEVICE_PATH); |
| 1748 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1749 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1750 | if (mDevices.find(ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID) == mDevices.end()) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1751 | createVirtualKeyboardLocked(); |
| 1752 | } |
| 1753 | } |
| 1754 | |
| 1755 | // ---------------------------------------------------------------------------- |
| 1756 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1757 | static const int32_t GAMEPAD_KEYCODES[] = { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1758 | AKEYCODE_BUTTON_A, AKEYCODE_BUTTON_B, AKEYCODE_BUTTON_C, // |
| 1759 | AKEYCODE_BUTTON_X, AKEYCODE_BUTTON_Y, AKEYCODE_BUTTON_Z, // |
| 1760 | AKEYCODE_BUTTON_L1, AKEYCODE_BUTTON_R1, // |
| 1761 | AKEYCODE_BUTTON_L2, AKEYCODE_BUTTON_R2, // |
| 1762 | AKEYCODE_BUTTON_THUMBL, AKEYCODE_BUTTON_THUMBR, // |
| 1763 | AKEYCODE_BUTTON_START, AKEYCODE_BUTTON_SELECT, AKEYCODE_BUTTON_MODE, // |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1764 | }; |
| 1765 | |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1766 | status_t EventHub::registerFdForEpoll(int fd) { |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1767 | // TODO(b/121395353) - consider adding EPOLLRDHUP |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1768 | struct epoll_event eventItem = {}; |
| 1769 | eventItem.events = EPOLLIN | EPOLLWAKEUP; |
| 1770 | eventItem.data.fd = fd; |
| 1771 | if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) { |
| 1772 | ALOGE("Could not add fd to epoll instance: %s", strerror(errno)); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 1773 | return -errno; |
| 1774 | } |
| 1775 | return OK; |
| 1776 | } |
| 1777 | |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1778 | status_t EventHub::unregisterFdFromEpoll(int fd) { |
| 1779 | if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, nullptr)) { |
| 1780 | ALOGW("Could not remove fd from epoll instance: %s", strerror(errno)); |
| 1781 | return -errno; |
| 1782 | } |
| 1783 | return OK; |
| 1784 | } |
| 1785 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1786 | status_t EventHub::registerDeviceForEpollLocked(Device& device) { |
| 1787 | status_t result = registerFdForEpoll(device.fd); |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1788 | if (result != OK) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1789 | ALOGE("Could not add input device fd to epoll for device %" PRId32, device.id); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1790 | return result; |
| 1791 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1792 | if (device.videoDevice) { |
| 1793 | registerVideoDeviceForEpollLocked(*device.videoDevice); |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1794 | } |
| 1795 | return result; |
| 1796 | } |
| 1797 | |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1798 | void EventHub::registerVideoDeviceForEpollLocked(const TouchVideoDevice& videoDevice) { |
| 1799 | status_t result = registerFdForEpoll(videoDevice.getFd()); |
| 1800 | if (result != OK) { |
| 1801 | ALOGE("Could not add video device %s to epoll", videoDevice.getName().c_str()); |
| 1802 | } |
| 1803 | } |
| 1804 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1805 | status_t EventHub::unregisterDeviceFromEpollLocked(Device& device) { |
| 1806 | if (device.hasValidFd()) { |
| 1807 | status_t result = unregisterFdFromEpoll(device.fd); |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1808 | if (result != OK) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1809 | ALOGW("Could not remove input device fd from epoll for device %" PRId32, device.id); |
Siarhei Vishniakou | 2592031 | 2018-12-12 15:24:44 -0800 | [diff] [blame] | 1810 | return result; |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 1811 | } |
| 1812 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1813 | if (device.videoDevice) { |
| 1814 | unregisterVideoDeviceFromEpollLocked(*device.videoDevice); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1815 | } |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 1816 | return OK; |
| 1817 | } |
| 1818 | |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1819 | void EventHub::unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& videoDevice) { |
| 1820 | if (videoDevice.hasValidFd()) { |
| 1821 | status_t result = unregisterFdFromEpoll(videoDevice.getFd()); |
| 1822 | if (result != OK) { |
| 1823 | ALOGW("Could not remove video device fd from epoll for device: %s", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1824 | videoDevice.getName().c_str()); |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 1825 | } |
| 1826 | } |
| 1827 | } |
| 1828 | |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 1829 | void EventHub::reportDeviceAddedForStatisticsLocked(const InputDeviceIdentifier& identifier, |
| 1830 | Flags<InputDeviceClass> classes) { |
| 1831 | android::util::stats_write(android::util::INPUTDEVICE_REGISTERED, identifier.name.c_str(), |
| 1832 | identifier.vendor, identifier.product, identifier.version, |
| 1833 | identifier.bus, identifier.uniqueId.c_str(), classes.get()); |
| 1834 | } |
| 1835 | |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 1836 | void EventHub::openDeviceLocked(const std::string& devicePath) { |
| 1837 | // If an input device happens to register around the time when EventHub's constructor runs, it |
| 1838 | // is possible that the same input event node (for example, /dev/input/event3) will be noticed |
| 1839 | // in both 'inotify' callback and also in the 'scanDirLocked' pass. To prevent duplicate devices |
| 1840 | // from getting registered, ensure that this path is not already covered by an existing device. |
| 1841 | for (const auto& [deviceId, device] : mDevices) { |
| 1842 | if (device->path == devicePath) { |
| 1843 | return; // device was already registered |
| 1844 | } |
| 1845 | } |
| 1846 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1847 | char buffer[80]; |
| 1848 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1849 | ALOGV("Opening device: %s", devicePath.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1850 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1851 | int fd = open(devicePath.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1852 | if (fd < 0) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1853 | ALOGE("could not open %s, %s\n", devicePath.c_str(), strerror(errno)); |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 1854 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1855 | } |
| 1856 | |
| 1857 | InputDeviceIdentifier identifier; |
| 1858 | |
| 1859 | // Get device name. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1860 | if (ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1861 | ALOGE("Could not get device name for %s: %s", devicePath.c_str(), strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1862 | } else { |
| 1863 | buffer[sizeof(buffer) - 1] = '\0'; |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1864 | identifier.name = buffer; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1865 | } |
| 1866 | |
| 1867 | // Check to see if the device is on our excluded list |
| 1868 | for (size_t i = 0; i < mExcludedDevices.size(); i++) { |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1869 | const std::string& item = mExcludedDevices[i]; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1870 | if (identifier.name == item) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1871 | ALOGI("ignoring event id %s driver %s\n", devicePath.c_str(), item.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1872 | close(fd); |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 1873 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1874 | } |
| 1875 | } |
| 1876 | |
| 1877 | // Get device driver version. |
| 1878 | int driverVersion; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1879 | if (ioctl(fd, EVIOCGVERSION, &driverVersion)) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1880 | ALOGE("could not get driver version for %s, %s\n", devicePath.c_str(), strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1881 | close(fd); |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 1882 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1883 | } |
| 1884 | |
| 1885 | // Get device identifier. |
| 1886 | struct input_id inputId; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1887 | if (ioctl(fd, EVIOCGID, &inputId)) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1888 | ALOGE("could not get device input id for %s, %s\n", devicePath.c_str(), strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1889 | close(fd); |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 1890 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1891 | } |
| 1892 | identifier.bus = inputId.bustype; |
| 1893 | identifier.product = inputId.product; |
| 1894 | identifier.vendor = inputId.vendor; |
| 1895 | identifier.version = inputId.version; |
| 1896 | |
| 1897 | // Get device physical location. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1898 | if (ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) { |
| 1899 | // fprintf(stderr, "could not get location for %s, %s\n", devicePath, strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1900 | } else { |
| 1901 | buffer[sizeof(buffer) - 1] = '\0'; |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1902 | identifier.location = buffer; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1903 | } |
| 1904 | |
| 1905 | // Get device unique id. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1906 | if (ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) { |
| 1907 | // fprintf(stderr, "could not get idstring for %s, %s\n", devicePath, strerror(errno)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1908 | } else { |
| 1909 | buffer[sizeof(buffer) - 1] = '\0'; |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1910 | identifier.uniqueId = buffer; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1911 | } |
| 1912 | |
| 1913 | // Fill in the descriptor. |
| 1914 | assignDescriptorLocked(identifier); |
| 1915 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1916 | // Allocate device. (The device object takes ownership of the fd at this point.) |
| 1917 | int32_t deviceId = mNextDeviceId++; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1918 | std::unique_ptr<Device> device = std::make_unique<Device>(fd, deviceId, devicePath, identifier); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1919 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 1920 | ALOGV("add device %d: %s\n", deviceId, devicePath.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1921 | ALOGV(" bus: %04x\n" |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1922 | " vendor %04x\n" |
| 1923 | " product %04x\n" |
| 1924 | " version %04x\n", |
| 1925 | identifier.bus, identifier.vendor, identifier.product, identifier.version); |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 1926 | ALOGV(" name: \"%s\"\n", identifier.name.c_str()); |
| 1927 | ALOGV(" location: \"%s\"\n", identifier.location.c_str()); |
| 1928 | ALOGV(" unique id: \"%s\"\n", identifier.uniqueId.c_str()); |
| 1929 | ALOGV(" descriptor: \"%s\"\n", identifier.descriptor.c_str()); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1930 | ALOGV(" driver: v%d.%d.%d\n", driverVersion >> 16, (driverVersion >> 8) & 0xff, |
| 1931 | driverVersion & 0xff); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1932 | |
| 1933 | // Load the configuration file for the device. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 1934 | device->loadConfigurationLocked(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1935 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1936 | bool hasBattery = false; |
| 1937 | bool hasLights = false; |
| 1938 | // Check the sysfs root path |
| 1939 | std::optional<std::filesystem::path> sysfsRootPath = getSysfsRootPath(devicePath.c_str()); |
| 1940 | if (sysfsRootPath.has_value()) { |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 1941 | std::shared_ptr<AssociatedDevice> associatedDevice; |
| 1942 | for (const auto& [id, dev] : mDevices) { |
| 1943 | if (device->identifier.descriptor == dev->identifier.descriptor && |
| 1944 | !dev->associatedDevice) { |
| 1945 | associatedDevice = dev->associatedDevice; |
| 1946 | } |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1947 | } |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 1948 | if (!associatedDevice) { |
| 1949 | associatedDevice = std::make_shared<AssociatedDevice>(sysfsRootPath.value()); |
| 1950 | } |
| 1951 | hasBattery = associatedDevice->configureBatteryLocked(); |
| 1952 | hasLights = associatedDevice->configureLightsLocked(); |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1953 | |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame^] | 1954 | device->associatedDevice = associatedDevice; |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 1955 | } |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 1956 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1957 | // Figure out the kinds of events the device reports. |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1958 | device->readDeviceBitMask(EVIOCGBIT(EV_KEY, 0), device->keyBitmask); |
| 1959 | device->readDeviceBitMask(EVIOCGBIT(EV_ABS, 0), device->absBitmask); |
| 1960 | device->readDeviceBitMask(EVIOCGBIT(EV_REL, 0), device->relBitmask); |
| 1961 | device->readDeviceBitMask(EVIOCGBIT(EV_SW, 0), device->swBitmask); |
| 1962 | device->readDeviceBitMask(EVIOCGBIT(EV_LED, 0), device->ledBitmask); |
| 1963 | device->readDeviceBitMask(EVIOCGBIT(EV_FF, 0), device->ffBitmask); |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 1964 | device->readDeviceBitMask(EVIOCGBIT(EV_MSC, 0), device->mscBitmask); |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1965 | device->readDeviceBitMask(EVIOCGPROP(0), device->propBitmask); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1966 | |
| 1967 | // See if this is a keyboard. Ignore everything in the button range except for |
| 1968 | // joystick and gamepad buttons which are handled like keyboards for the most part. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1969 | bool haveKeyboardKeys = |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1970 | device->keyBitmask.any(0, BTN_MISC) || device->keyBitmask.any(BTN_WHEEL, KEY_MAX + 1); |
| 1971 | bool haveGamepadButtons = device->keyBitmask.any(BTN_MISC, BTN_MOUSE) || |
| 1972 | device->keyBitmask.any(BTN_JOYSTICK, BTN_DIGI); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1973 | if (haveKeyboardKeys || haveGamepadButtons) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 1974 | device->classes |= InputDeviceClass::KEYBOARD; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1975 | } |
| 1976 | |
| 1977 | // See if this is a cursor device such as a trackball or mouse. |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1978 | if (device->keyBitmask.test(BTN_MOUSE) && device->relBitmask.test(REL_X) && |
| 1979 | device->relBitmask.test(REL_Y)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 1980 | device->classes |= InputDeviceClass::CURSOR; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1981 | } |
| 1982 | |
Prashant Malani | 1941ff5 | 2015-08-11 18:29:28 -0700 | [diff] [blame] | 1983 | // See if this is a rotary encoder type device. |
| 1984 | String8 deviceType = String8(); |
| 1985 | if (device->configuration && |
| 1986 | device->configuration->tryGetProperty(String8("device.type"), deviceType)) { |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1987 | if (!deviceType.compare(String8("rotaryEncoder"))) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 1988 | device->classes |= InputDeviceClass::ROTARY_ENCODER; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 1989 | } |
Prashant Malani | 1941ff5 | 2015-08-11 18:29:28 -0700 | [diff] [blame] | 1990 | } |
| 1991 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1992 | // See if this is a touch pad. |
| 1993 | // Is this a new modern multi-touch driver? |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1994 | if (device->absBitmask.test(ABS_MT_POSITION_X) && device->absBitmask.test(ABS_MT_POSITION_Y)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 1995 | // Some joysticks such as the PS3 controller report axes that conflict |
| 1996 | // with the ABS_MT range. Try to confirm that the device really is |
| 1997 | // a touch screen. |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 1998 | if (device->keyBitmask.test(BTN_TOUCH) || !haveGamepadButtons) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 1999 | device->classes |= (InputDeviceClass::TOUCH | InputDeviceClass::TOUCH_MT); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2000 | } |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2001 | // Is this an old style single-touch driver? |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 2002 | } else if (device->keyBitmask.test(BTN_TOUCH) && device->absBitmask.test(ABS_X) && |
| 2003 | device->absBitmask.test(ABS_Y)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2004 | device->classes |= InputDeviceClass::TOUCH; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2005 | // Is this a BT stylus? |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 2006 | } else if ((device->absBitmask.test(ABS_PRESSURE) || device->keyBitmask.test(BTN_TOUCH)) && |
| 2007 | !device->absBitmask.test(ABS_X) && !device->absBitmask.test(ABS_Y)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2008 | device->classes |= InputDeviceClass::EXTERNAL_STYLUS; |
Michael Wright | 842500e | 2015-03-13 17:32:02 -0700 | [diff] [blame] | 2009 | // Keyboard will try to claim some of the buttons but we really want to reserve those so we |
| 2010 | // can fuse it with the touch screen data, so just take them back. Note this means an |
| 2011 | // external stylus cannot also be a keyboard device. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2012 | device->classes &= ~InputDeviceClass::KEYBOARD; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2013 | } |
| 2014 | |
| 2015 | // See if this device is a joystick. |
| 2016 | // Assumes that joysticks always have gamepad buttons in order to distinguish them |
| 2017 | // from other devices such as accelerometers that also have absolute axes. |
| 2018 | if (haveGamepadButtons) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2019 | auto assumedClasses = device->classes | InputDeviceClass::JOYSTICK; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2020 | for (int i = 0; i <= ABS_MAX; i++) { |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 2021 | if (device->absBitmask.test(i) && |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2022 | (getAbsAxisUsage(i, assumedClasses).test(InputDeviceClass::JOYSTICK))) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2023 | device->classes = assumedClasses; |
| 2024 | break; |
| 2025 | } |
| 2026 | } |
| 2027 | } |
| 2028 | |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 2029 | // Check whether this device is an accelerometer. |
| 2030 | if (device->propBitmask.test(INPUT_PROP_ACCELEROMETER)) { |
| 2031 | device->classes |= InputDeviceClass::SENSOR; |
| 2032 | } |
| 2033 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2034 | // Check whether this device has switches. |
| 2035 | for (int i = 0; i <= SW_MAX; i++) { |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 2036 | if (device->swBitmask.test(i)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2037 | device->classes |= InputDeviceClass::SWITCH; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2038 | break; |
| 2039 | } |
| 2040 | } |
| 2041 | |
| 2042 | // Check whether this device supports the vibrator. |
Chris Ye | 66fbac3 | 2020-07-06 20:36:43 -0700 | [diff] [blame] | 2043 | if (device->ffBitmask.test(FF_RUMBLE)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2044 | device->classes |= InputDeviceClass::VIBRATOR; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2045 | } |
| 2046 | |
| 2047 | // Configure virtual keys. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2048 | if ((device->classes.test(InputDeviceClass::TOUCH))) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2049 | // Load the virtual keys for the touch screen, if any. |
| 2050 | // We do this now so that we can make sure to load the keymap if necessary. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2051 | bool success = device->loadVirtualKeyMapLocked(); |
Siarhei Vishniakou | 3e78dec | 2019-02-20 16:21:46 -0600 | [diff] [blame] | 2052 | if (success) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2053 | device->classes |= InputDeviceClass::KEYBOARD; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2054 | } |
| 2055 | } |
| 2056 | |
| 2057 | // Load the key map. |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 2058 | // We need to do this for joysticks too because the key layout may specify axes, and for |
| 2059 | // sensor as well because the key layout may specify the axes to sensor data mapping. |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2060 | status_t keyMapStatus = NAME_NOT_FOUND; |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 2061 | if (device->classes.any(InputDeviceClass::KEYBOARD | InputDeviceClass::JOYSTICK | |
| 2062 | InputDeviceClass::SENSOR)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2063 | // Load the keymap for the device. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2064 | keyMapStatus = device->loadKeyMapLocked(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2065 | } |
| 2066 | |
| 2067 | // Configure the keyboard, gamepad or virtual keyboard. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2068 | if (device->classes.test(InputDeviceClass::KEYBOARD)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2069 | // Register the keyboard as a built-in keyboard if it is eligible. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2070 | if (!keyMapStatus && mBuiltInKeyboardId == NO_BUILT_IN_KEYBOARD && |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 2071 | isEligibleBuiltInKeyboard(device->identifier, device->configuration.get(), |
| 2072 | &device->keyMap)) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2073 | mBuiltInKeyboardId = device->id; |
| 2074 | } |
| 2075 | |
| 2076 | // 'Q' key support = cheap test of whether this is an alpha-capable kbd |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2077 | if (device->hasKeycodeLocked(AKEYCODE_Q)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2078 | device->classes |= InputDeviceClass::ALPHAKEY; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2079 | } |
| 2080 | |
| 2081 | // See if this device has a DPAD. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2082 | if (device->hasKeycodeLocked(AKEYCODE_DPAD_UP) && |
| 2083 | device->hasKeycodeLocked(AKEYCODE_DPAD_DOWN) && |
| 2084 | device->hasKeycodeLocked(AKEYCODE_DPAD_LEFT) && |
| 2085 | device->hasKeycodeLocked(AKEYCODE_DPAD_RIGHT) && |
| 2086 | device->hasKeycodeLocked(AKEYCODE_DPAD_CENTER)) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2087 | device->classes |= InputDeviceClass::DPAD; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2088 | } |
| 2089 | |
| 2090 | // See if this device has a gamepad. |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2091 | for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES) / sizeof(GAMEPAD_KEYCODES[0]); i++) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2092 | if (device->hasKeycodeLocked(GAMEPAD_KEYCODES[i])) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2093 | device->classes |= InputDeviceClass::GAMEPAD; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2094 | break; |
| 2095 | } |
| 2096 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2097 | } |
| 2098 | |
| 2099 | // If the device isn't recognized as something we handle, don't monitor it. |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2100 | if (device->classes == Flags<InputDeviceClass>(0)) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2101 | ALOGV("Dropping device: id=%d, path='%s', name='%s'", deviceId, devicePath.c_str(), |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2102 | device->identifier.name.c_str()); |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 2103 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2104 | } |
| 2105 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 2106 | // Classify InputDeviceClass::BATTERY. |
| 2107 | if (hasBattery) { |
| 2108 | device->classes |= InputDeviceClass::BATTERY; |
| 2109 | } |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 2110 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 2111 | // Classify InputDeviceClass::LIGHT. |
| 2112 | if (hasLights) { |
| 2113 | device->classes |= InputDeviceClass::LIGHT; |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 2114 | } |
| 2115 | |
Tim Kilbourn | 063ff53 | 2015-04-08 10:26:18 -0700 | [diff] [blame] | 2116 | // Determine whether the device has a mic. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2117 | if (device->deviceHasMicLocked()) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2118 | device->classes |= InputDeviceClass::MIC; |
Tim Kilbourn | 063ff53 | 2015-04-08 10:26:18 -0700 | [diff] [blame] | 2119 | } |
| 2120 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2121 | // Determine whether the device is external or internal. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2122 | if (device->isExternalDeviceLocked()) { |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2123 | device->classes |= InputDeviceClass::EXTERNAL; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2124 | } |
| 2125 | |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2126 | if (device->classes.any(InputDeviceClass::JOYSTICK | InputDeviceClass::DPAD) && |
| 2127 | device->classes.test(InputDeviceClass::GAMEPAD)) { |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2128 | device->controllerNumber = getNextControllerNumberLocked(device->identifier.name); |
| 2129 | device->setLedForControllerLocked(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2130 | } |
| 2131 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2132 | if (registerDeviceForEpollLocked(*device) != OK) { |
Siarhei Vishniakou | a4c502a | 2021-02-05 00:45:20 +0000 | [diff] [blame] | 2133 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2134 | } |
| 2135 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2136 | device->configureFd(); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2137 | |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2138 | ALOGI("New device: id=%d, fd=%d, path='%s', name='%s', classes=%s, " |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2139 | "configuration='%s', keyLayout='%s', keyCharacterMap='%s', builtinKeyboard=%s, ", |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2140 | deviceId, fd, devicePath.c_str(), device->identifier.name.c_str(), |
| 2141 | device->classes.string().c_str(), device->configurationFile.c_str(), |
| 2142 | device->keyMap.keyLayoutFile.c_str(), device->keyMap.keyCharacterMapFile.c_str(), |
| 2143 | toString(mBuiltInKeyboardId == deviceId)); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2144 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2145 | addDeviceLocked(std::move(device)); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2146 | } |
| 2147 | |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2148 | void EventHub::openVideoDeviceLocked(const std::string& devicePath) { |
| 2149 | std::unique_ptr<TouchVideoDevice> videoDevice = TouchVideoDevice::create(devicePath); |
| 2150 | if (!videoDevice) { |
| 2151 | ALOGE("Could not create touch video device for %s. Ignoring", devicePath.c_str()); |
| 2152 | return; |
| 2153 | } |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2154 | // Transfer ownership of this video device to a matching input device |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2155 | for (const auto& [id, device] : mDevices) { |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 2156 | if (tryAddVideoDeviceLocked(*device, videoDevice)) { |
Siarhei Vishniakou | f49608d | 2020-08-20 19:18:21 -0500 | [diff] [blame] | 2157 | return; // 'device' now owns 'videoDevice' |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2158 | } |
| 2159 | } |
| 2160 | |
| 2161 | // Couldn't find a matching input device, so just add it to a temporary holding queue. |
| 2162 | // A matching input device may appear later. |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2163 | ALOGI("Adding video device %s to list of unattached video devices", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2164 | videoDevice->getName().c_str()); |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2165 | mUnattachedVideoDevices.push_back(std::move(videoDevice)); |
| 2166 | } |
| 2167 | |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 2168 | bool EventHub::tryAddVideoDeviceLocked(EventHub::Device& device, |
| 2169 | std::unique_ptr<TouchVideoDevice>& videoDevice) { |
Siarhei Vishniakou | f49608d | 2020-08-20 19:18:21 -0500 | [diff] [blame] | 2170 | if (videoDevice->getName() != device.identifier.name) { |
| 2171 | return false; |
| 2172 | } |
| 2173 | device.videoDevice = std::move(videoDevice); |
| 2174 | if (device.enabled) { |
| 2175 | registerVideoDeviceForEpollLocked(*device.videoDevice); |
| 2176 | } |
| 2177 | return true; |
| 2178 | } |
| 2179 | |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2180 | bool EventHub::isDeviceEnabled(int32_t deviceId) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 2181 | std::scoped_lock _l(mLock); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2182 | Device* device = getDeviceLocked(deviceId); |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 2183 | if (device == nullptr) { |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2184 | ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__); |
| 2185 | return false; |
| 2186 | } |
| 2187 | return device->enabled; |
| 2188 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2189 | |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2190 | status_t EventHub::enableDevice(int32_t deviceId) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 2191 | std::scoped_lock _l(mLock); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2192 | Device* device = getDeviceLocked(deviceId); |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 2193 | if (device == nullptr) { |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2194 | ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__); |
| 2195 | return BAD_VALUE; |
| 2196 | } |
| 2197 | if (device->enabled) { |
| 2198 | ALOGW("Duplicate call to %s, input device %" PRId32 " already enabled", __func__, deviceId); |
| 2199 | return OK; |
| 2200 | } |
| 2201 | status_t result = device->enable(); |
| 2202 | if (result != OK) { |
| 2203 | ALOGE("Failed to enable device %" PRId32, deviceId); |
| 2204 | return result; |
| 2205 | } |
| 2206 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2207 | device->configureFd(); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2208 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2209 | return registerDeviceForEpollLocked(*device); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2210 | } |
| 2211 | |
| 2212 | status_t EventHub::disableDevice(int32_t deviceId) { |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 2213 | std::scoped_lock _l(mLock); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2214 | Device* device = getDeviceLocked(deviceId); |
Yi Kong | 9b14ac6 | 2018-07-17 13:48:38 -0700 | [diff] [blame] | 2215 | if (device == nullptr) { |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2216 | ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__); |
| 2217 | return BAD_VALUE; |
| 2218 | } |
| 2219 | if (!device->enabled) { |
| 2220 | ALOGW("Duplicate call to %s, input device already disabled", __func__); |
| 2221 | return OK; |
| 2222 | } |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2223 | unregisterDeviceFromEpollLocked(*device); |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2224 | return device->disable(); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2225 | } |
| 2226 | |
| 2227 | void EventHub::createVirtualKeyboardLocked() { |
| 2228 | InputDeviceIdentifier identifier; |
| 2229 | identifier.name = "Virtual"; |
| 2230 | identifier.uniqueId = "<virtual>"; |
| 2231 | assignDescriptorLocked(identifier); |
| 2232 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2233 | std::unique_ptr<Device> device = |
| 2234 | std::make_unique<Device>(-1, ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID, "<virtual>", |
| 2235 | identifier); |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2236 | device->classes = InputDeviceClass::KEYBOARD | InputDeviceClass::ALPHAKEY | |
| 2237 | InputDeviceClass::DPAD | InputDeviceClass::VIRTUAL; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2238 | device->loadKeyMapLocked(); |
| 2239 | addDeviceLocked(std::move(device)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2240 | } |
| 2241 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2242 | void EventHub::addDeviceLocked(std::unique_ptr<Device> device) { |
Chris Ye | d3fef46 | 2021-03-07 17:10:08 -0800 | [diff] [blame] | 2243 | reportDeviceAddedForStatisticsLocked(device->identifier, device->classes); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2244 | mOpeningDevices.push_back(std::move(device)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2245 | } |
| 2246 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2247 | int32_t EventHub::getNextControllerNumberLocked(const std::string& name) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2248 | if (mControllerNumbers.isFull()) { |
| 2249 | ALOGI("Maximum number of controllers reached, assigning controller number 0 to device %s", |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2250 | name.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2251 | return 0; |
| 2252 | } |
| 2253 | // Since the controller number 0 is reserved for non-controllers, translate all numbers up by |
| 2254 | // one |
| 2255 | return static_cast<int32_t>(mControllerNumbers.markFirstUnmarkedBit() + 1); |
| 2256 | } |
| 2257 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2258 | void EventHub::releaseControllerNumberLocked(int32_t num) { |
| 2259 | if (num > 0) { |
| 2260 | mControllerNumbers.clearBit(static_cast<uint32_t>(num - 1)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2261 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2262 | } |
| 2263 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2264 | void EventHub::closeDeviceByPathLocked(const std::string& devicePath) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2265 | Device* device = getDeviceByPathLocked(devicePath); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2266 | if (device != nullptr) { |
| 2267 | closeDeviceLocked(*device); |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2268 | return; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2269 | } |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2270 | ALOGV("Remove device: %s not found, device may already have been removed.", devicePath.c_str()); |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2271 | } |
| 2272 | |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2273 | /** |
| 2274 | * Find the video device by filename, and close it. |
| 2275 | * The video device is closed by path during an inotify event, where we don't have the |
| 2276 | * additional context about the video device fd, or the associated input device. |
| 2277 | */ |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2278 | void EventHub::closeVideoDeviceByPathLocked(const std::string& devicePath) { |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2279 | // A video device may be owned by an existing input device, or it may be stored in |
| 2280 | // the mUnattachedVideoDevices queue. Check both locations. |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2281 | for (const auto& [id, device] : mDevices) { |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2282 | if (device->videoDevice && device->videoDevice->getPath() == devicePath) { |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 2283 | unregisterVideoDeviceFromEpollLocked(*device->videoDevice); |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2284 | device->videoDevice = nullptr; |
| 2285 | return; |
| 2286 | } |
| 2287 | } |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2288 | mUnattachedVideoDevices |
| 2289 | .erase(std::remove_if(mUnattachedVideoDevices.begin(), mUnattachedVideoDevices.end(), |
| 2290 | [&devicePath]( |
| 2291 | const std::unique_ptr<TouchVideoDevice>& videoDevice) { |
| 2292 | return videoDevice->getPath() == devicePath; |
| 2293 | }), |
| 2294 | mUnattachedVideoDevices.end()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2295 | } |
| 2296 | |
| 2297 | void EventHub::closeAllDevicesLocked() { |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2298 | mUnattachedVideoDevices.clear(); |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 2299 | while (!mDevices.empty()) { |
| 2300 | closeDeviceLocked(*(mDevices.begin()->second)); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2301 | } |
| 2302 | } |
| 2303 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2304 | void EventHub::closeDeviceLocked(Device& device) { |
| 2305 | ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=%s", device.path.c_str(), |
| 2306 | device.identifier.name.c_str(), device.id, device.fd, device.classes.string().c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2307 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2308 | if (device.id == mBuiltInKeyboardId) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2309 | ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this", |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2310 | device.path.c_str(), mBuiltInKeyboardId); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2311 | mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD; |
| 2312 | } |
| 2313 | |
Siarhei Vishniakou | e54cb85 | 2017-03-21 17:48:16 -0700 | [diff] [blame] | 2314 | unregisterDeviceFromEpollLocked(device); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2315 | if (device.videoDevice) { |
Siarhei Vishniakou | 1259868 | 2018-11-02 17:19:19 -0700 | [diff] [blame] | 2316 | // This must be done after the video device is removed from epoll |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2317 | mUnattachedVideoDevices.push_back(std::move(device.videoDevice)); |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2318 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2319 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2320 | releaseControllerNumberLocked(device.controllerNumber); |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 2321 | device.controllerNumber = 0; |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2322 | device.close(); |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2323 | mClosingDevices.push_back(std::move(mDevices[device.id])); |
Siarhei Vishniakou | d549b25 | 2020-08-11 11:25:26 -0500 | [diff] [blame] | 2324 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2325 | mDevices.erase(device.id); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2326 | } |
| 2327 | |
| 2328 | status_t EventHub::readNotifyLocked() { |
| 2329 | int res; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2330 | char event_buf[512]; |
| 2331 | int event_size; |
| 2332 | int event_pos = 0; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2333 | struct inotify_event* event; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2334 | |
| 2335 | ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd); |
| 2336 | res = read(mINotifyFd, event_buf, sizeof(event_buf)); |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2337 | if (res < (int)sizeof(*event)) { |
| 2338 | if (errno == EINTR) return 0; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2339 | ALOGW("could not get event, %s\n", strerror(errno)); |
| 2340 | return -1; |
| 2341 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2342 | |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2343 | while (res >= (int)sizeof(*event)) { |
| 2344 | event = (struct inotify_event*)(event_buf + event_pos); |
| 2345 | if (event->len) { |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2346 | if (event->wd == mInputWd) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2347 | std::string filename = std::string(DEVICE_PATH) + "/" + event->name; |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2348 | if (event->mask & IN_CREATE) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2349 | openDeviceLocked(filename); |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2350 | } else { |
| 2351 | ALOGI("Removing device '%s' due to inotify event\n", filename.c_str()); |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2352 | closeDeviceByPathLocked(filename); |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2353 | } |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2354 | } else if (event->wd == mVideoWd) { |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2355 | if (isV4lTouchNode(event->name)) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2356 | std::string filename = std::string(VIDEO_DEVICE_PATH) + "/" + event->name; |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2357 | if (event->mask & IN_CREATE) { |
| 2358 | openVideoDeviceLocked(filename); |
| 2359 | } else { |
| 2360 | ALOGI("Removing video device '%s' due to inotify event", filename.c_str()); |
| 2361 | closeVideoDeviceByPathLocked(filename); |
| 2362 | } |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2363 | } |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2364 | } else { |
Siarhei Vishniakou | 951f362 | 2018-12-12 19:45:42 -0800 | [diff] [blame] | 2365 | LOG_ALWAYS_FATAL("Unexpected inotify event, wd = %i", event->wd); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2366 | } |
| 2367 | } |
| 2368 | event_size = sizeof(*event) + event->len; |
| 2369 | res -= event_size; |
| 2370 | event_pos += event_size; |
| 2371 | } |
| 2372 | return 0; |
| 2373 | } |
| 2374 | |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2375 | status_t EventHub::scanDirLocked(const std::string& dirname) { |
| 2376 | for (const auto& entry : std::filesystem::directory_iterator(dirname)) { |
| 2377 | openDeviceLocked(entry.path()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2378 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2379 | return 0; |
| 2380 | } |
| 2381 | |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2382 | /** |
| 2383 | * Look for all dirname/v4l-touch* devices, and open them. |
| 2384 | */ |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2385 | status_t EventHub::scanVideoDirLocked(const std::string& dirname) { |
Chris Ye | 8594e19 | 2020-07-14 10:34:06 -0700 | [diff] [blame] | 2386 | for (const auto& entry : std::filesystem::directory_iterator(dirname)) { |
| 2387 | if (isV4lTouchNode(entry.path())) { |
| 2388 | ALOGI("Found touch video device %s", entry.path().c_str()); |
| 2389 | openVideoDeviceLocked(entry.path()); |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2390 | } |
| 2391 | } |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2392 | return OK; |
| 2393 | } |
| 2394 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2395 | void EventHub::requestReopenDevices() { |
| 2396 | ALOGV("requestReopenDevices() called"); |
| 2397 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 2398 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2399 | mNeedToReopenDevices = true; |
| 2400 | } |
| 2401 | |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2402 | void EventHub::dump(std::string& dump) { |
| 2403 | dump += "Event Hub State:\n"; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2404 | |
| 2405 | { // acquire lock |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 2406 | std::scoped_lock _l(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2407 | |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2408 | dump += StringPrintf(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2409 | |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2410 | dump += INDENT "Devices:\n"; |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2411 | |
Chris Ye | 989bb93 | 2020-07-04 16:18:59 -0700 | [diff] [blame] | 2412 | for (const auto& [id, device] : mDevices) { |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2413 | if (mBuiltInKeyboardId == device->id) { |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2414 | dump += StringPrintf(INDENT2 "%d: %s (aka device 0 - built-in keyboard)\n", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2415 | device->id, device->identifier.name.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2416 | } else { |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2417 | dump += StringPrintf(INDENT2 "%d: %s\n", device->id, |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2418 | device->identifier.name.c_str()); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2419 | } |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 2420 | dump += StringPrintf(INDENT3 "Classes: %s\n", device->classes.string().c_str()); |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 2421 | dump += StringPrintf(INDENT3 "Path: %s\n", device->path.c_str()); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2422 | dump += StringPrintf(INDENT3 "Enabled: %s\n", toString(device->enabled)); |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 2423 | dump += StringPrintf(INDENT3 "Descriptor: %s\n", device->identifier.descriptor.c_str()); |
| 2424 | dump += StringPrintf(INDENT3 "Location: %s\n", device->identifier.location.c_str()); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2425 | dump += StringPrintf(INDENT3 "ControllerNumber: %d\n", device->controllerNumber); |
Siarhei Vishniakou | ec8f725 | 2018-07-06 11:19:32 +0100 | [diff] [blame] | 2426 | dump += StringPrintf(INDENT3 "UniqueId: %s\n", device->identifier.uniqueId.c_str()); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2427 | dump += StringPrintf(INDENT3 "Identifier: bus=0x%04x, vendor=0x%04x, " |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2428 | "product=0x%04x, version=0x%04x\n", |
| 2429 | device->identifier.bus, device->identifier.vendor, |
| 2430 | device->identifier.product, device->identifier.version); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2431 | dump += StringPrintf(INDENT3 "KeyLayoutFile: %s\n", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2432 | device->keyMap.keyLayoutFile.c_str()); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2433 | dump += StringPrintf(INDENT3 "KeyCharacterMapFile: %s\n", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2434 | device->keyMap.keyCharacterMapFile.c_str()); |
Siarhei Vishniakou | f93fcf4 | 2017-11-22 16:00:14 -0800 | [diff] [blame] | 2435 | dump += StringPrintf(INDENT3 "ConfigurationFile: %s\n", |
Prabir Pradhan | da7c00c | 2019-08-29 14:12:42 -0700 | [diff] [blame] | 2436 | device->configurationFile.c_str()); |
Siarhei Vishniakou | ec7854a | 2018-12-14 16:52:34 -0800 | [diff] [blame] | 2437 | dump += INDENT3 "VideoDevice: "; |
| 2438 | if (device->videoDevice) { |
| 2439 | dump += device->videoDevice->dump() + "\n"; |
| 2440 | } else { |
| 2441 | dump += "<none>\n"; |
| 2442 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2443 | } |
Siarhei Vishniakou | 22c8846 | 2018-12-13 19:34:53 -0800 | [diff] [blame] | 2444 | |
| 2445 | dump += INDENT "Unattached video devices:\n"; |
| 2446 | for (const std::unique_ptr<TouchVideoDevice>& videoDevice : mUnattachedVideoDevices) { |
| 2447 | dump += INDENT2 + videoDevice->dump() + "\n"; |
| 2448 | } |
| 2449 | if (mUnattachedVideoDevices.empty()) { |
| 2450 | dump += INDENT2 "<none>\n"; |
| 2451 | } |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2452 | } // release lock |
| 2453 | } |
| 2454 | |
| 2455 | void EventHub::monitor() { |
| 2456 | // Acquire and release the lock to ensure that the event hub has not deadlocked. |
Chris Ye | 1c2e089 | 2020-11-30 21:41:44 -0800 | [diff] [blame] | 2457 | std::unique_lock<std::mutex> lock(mLock); |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2458 | } |
| 2459 | |
Michael Wright | d02c5b6 | 2014-02-10 15:10:22 -0800 | [diff] [blame] | 2460 | }; // namespace android |