blob: 166f3585983ca4a800acacc19f7abe3f46c658b0 [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
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 Salyzyn5aa26b22014-06-10 13:07:44 -070017#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 Vishniakou7a522bf2019-09-24 12:46:29 +010027#include <sys/capability.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070028#include <sys/epoll.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070029#include <sys/inotify.h>
30#include <sys/ioctl.h>
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070031#include <sys/limits.h>
Kim Low03ea0352020-11-06 12:45:07 -080032#include <sys/stat.h>
33#include <sys/sysmacros.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070034#include <unistd.h>
35
Michael Wrightd02c5b62014-02-10 15:10:22 -080036#define LOG_TAG "EventHub"
37
38// #define LOG_NDEBUG 0
Kim Low03ea0352020-11-06 12:45:07 -080039#include <android-base/file.h>
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080040#include <android-base/stringprintf.h>
Chris Yed3fef462021-03-07 17:10:08 -080041#include <android-base/strings.h>
Philip Quinn39b81682019-01-09 22:20:39 -080042#include <cutils/properties.h>
Chris Ye8594e192020-07-14 10:34:06 -070043#include <input/KeyCharacterMap.h>
44#include <input/KeyLayoutMap.h>
45#include <input/VirtualKeyMap.h>
Dan Albert677d87e2014-06-16 17:31:28 -070046#include <openssl/sha.h>
Chris Yed3fef462021-03-07 17:10:08 -080047#include <statslog.h>
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070048#include <utils/Errors.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080049#include <utils/Log.h>
50#include <utils/Timers.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080051
Chris Ye8594e192020-07-14 10:34:06 -070052#include <filesystem>
Chris Ye3fdbfef2021-01-06 18:45:18 -080053#include <regex>
Chris Ye8594e192020-07-14 10:34:06 -070054
55#include "EventHub.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080056
Michael Wrightd02c5b62014-02-10 15:10:22 -080057#define INDENT " "
58#define INDENT2 " "
59#define INDENT3 " "
60
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080061using android::base::StringPrintf;
Chris Ye1b0c7342020-07-28 21:57:03 -070062using namespace android::flag_operators;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080063
Michael Wrightd02c5b62014-02-10 15:10:22 -080064namespace android {
65
Usama Arif78eb9752021-06-03 16:44:09 +010066static const char* DEVICE_INPUT_PATH = "/dev/input";
Siarhei Vishniakou951f3622018-12-12 19:45:42 -080067// v4l2 devices go directly into /dev
Usama Arif78eb9752021-06-03 16:44:09 +010068static const char* DEVICE_PATH = "/dev";
Michael Wrightd02c5b62014-02-10 15:10:22 -080069
Chris Ye657c2f02021-05-25 16:24:37 -070070static constexpr size_t OBFUSCATED_LENGTH = 8;
71
Chris Ye87143712020-11-10 05:05:58 +000072static constexpr int32_t FF_STRONG_MAGNITUDE_CHANNEL_IDX = 0;
73static constexpr int32_t FF_WEAK_MAGNITUDE_CHANNEL_IDX = 1;
Chris Ye6393a262020-08-04 19:41:36 -070074
Chris Yee2b1e5c2021-03-10 22:45:12 -080075// Mapping for input battery class node IDs lookup.
76// https://www.kernel.org/doc/Documentation/power/power_supply_class.txt
77static const std::unordered_map<std::string, InputBatteryClass> BATTERY_CLASSES =
78 {{"capacity", InputBatteryClass::CAPACITY},
79 {"capacity_level", InputBatteryClass::CAPACITY_LEVEL},
80 {"status", InputBatteryClass::STATUS}};
81
82// Mapping for input battery class node names lookup.
83// https://www.kernel.org/doc/Documentation/power/power_supply_class.txt
84static const std::unordered_map<InputBatteryClass, std::string> BATTERY_NODES =
85 {{InputBatteryClass::CAPACITY, "capacity"},
86 {InputBatteryClass::CAPACITY_LEVEL, "capacity_level"},
87 {InputBatteryClass::STATUS, "status"}};
88
Kim Low03ea0352020-11-06 12:45:07 -080089// must be kept in sync with definitions in kernel /drivers/power/supply/power_supply_sysfs.c
90static const std::unordered_map<std::string, int32_t> BATTERY_STATUS =
91 {{"Unknown", BATTERY_STATUS_UNKNOWN},
92 {"Charging", BATTERY_STATUS_CHARGING},
93 {"Discharging", BATTERY_STATUS_DISCHARGING},
94 {"Not charging", BATTERY_STATUS_NOT_CHARGING},
95 {"Full", BATTERY_STATUS_FULL}};
96
97// Mapping taken from
98// https://gitlab.freedesktop.org/upower/upower/-/blob/master/src/linux/up-device-supply.c#L484
99static const std::unordered_map<std::string, int32_t> BATTERY_LEVEL = {{"Critical", 5},
100 {"Low", 10},
101 {"Normal", 55},
102 {"High", 70},
103 {"Full", 100},
104 {"Unknown", 50}};
105
Chris Ye3fdbfef2021-01-06 18:45:18 -0800106// Mapping for input led class node names lookup.
107// https://www.kernel.org/doc/html/latest/leds/leds-class.html
108static const std::unordered_map<std::string, InputLightClass> LIGHT_CLASSES =
109 {{"red", InputLightClass::RED},
110 {"green", InputLightClass::GREEN},
111 {"blue", InputLightClass::BLUE},
112 {"global", InputLightClass::GLOBAL},
113 {"brightness", InputLightClass::BRIGHTNESS},
114 {"multi_index", InputLightClass::MULTI_INDEX},
115 {"multi_intensity", InputLightClass::MULTI_INTENSITY},
116 {"max_brightness", InputLightClass::MAX_BRIGHTNESS}};
117
118// Mapping for input multicolor led class node names.
119// https://www.kernel.org/doc/html/latest/leds/leds-class-multicolor.html
120static const std::unordered_map<InputLightClass, std::string> LIGHT_NODES =
121 {{InputLightClass::BRIGHTNESS, "brightness"},
122 {InputLightClass::MULTI_INDEX, "multi_index"},
123 {InputLightClass::MULTI_INTENSITY, "multi_intensity"}};
124
125// Mapping for light color name and the light color
126const std::unordered_map<std::string, LightColor> LIGHT_COLORS = {{"red", LightColor::RED},
127 {"green", LightColor::GREEN},
128 {"blue", LightColor::BLUE}};
129
Michael Wrightd02c5b62014-02-10 15:10:22 -0800130static inline const char* toString(bool value) {
131 return value ? "true" : "false";
132}
133
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100134static std::string sha1(const std::string& in) {
Dan Albert677d87e2014-06-16 17:31:28 -0700135 SHA_CTX ctx;
136 SHA1_Init(&ctx);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100137 SHA1_Update(&ctx, reinterpret_cast<const u_char*>(in.c_str()), in.size());
Dan Albert677d87e2014-06-16 17:31:28 -0700138 u_char digest[SHA_DIGEST_LENGTH];
139 SHA1_Final(digest, &ctx);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800140
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100141 std::string out;
Dan Albert677d87e2014-06-16 17:31:28 -0700142 for (size_t i = 0; i < SHA_DIGEST_LENGTH; i++) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100143 out += StringPrintf("%02x", digest[i]);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800144 }
145 return out;
146}
147
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800148/**
149 * Return true if name matches "v4l-touch*"
150 */
Chris Ye8594e192020-07-14 10:34:06 -0700151static bool isV4lTouchNode(std::string name) {
152 return name.find("v4l-touch") != std::string::npos;
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800153}
154
Philip Quinn39b81682019-01-09 22:20:39 -0800155/**
156 * Returns true if V4L devices should be scanned.
157 *
158 * The system property ro.input.video_enabled can be used to control whether
159 * EventHub scans and opens V4L devices. As V4L does not support multiple
160 * clients, EventHub effectively blocks access to these devices when it opens
Siarhei Vishniakou29f88492019-04-05 14:11:43 -0700161 * them.
162 *
163 * Setting this to "false" would prevent any video devices from being discovered and
164 * associated with input devices.
165 *
166 * This property can be used as follows:
167 * 1. To turn off features that are dependent on video device presence.
168 * 2. During testing and development, to allow other clients to read video devices
169 * directly from /dev.
Philip Quinn39b81682019-01-09 22:20:39 -0800170 */
171static bool isV4lScanningEnabled() {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700172 return property_get_bool("ro.input.video_enabled", true /* default_value */);
Philip Quinn39b81682019-01-09 22:20:39 -0800173}
174
Siarhei Vishniakou592bac22018-11-08 19:42:38 -0800175static nsecs_t processEventTimestamp(const struct input_event& event) {
176 // Use the time specified in the event instead of the current time
177 // so that downstream code can get more accurate estimates of
178 // event dispatch latency from the time the event is enqueued onto
179 // the evdev client buffer.
180 //
181 // The event's timestamp fortuitously uses the same monotonic clock
182 // time base as the rest of Android. The kernel event device driver
183 // (drivers/input/evdev.c) obtains timestamps using ktime_get_ts().
184 // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
185 // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a
186 // system call that also queries ktime_get_ts().
187
188 const nsecs_t inputEventTime = seconds_to_nanoseconds(event.time.tv_sec) +
189 microseconds_to_nanoseconds(event.time.tv_usec);
190 return inputEventTime;
191}
192
Kim Low03ea0352020-11-06 12:45:07 -0800193/**
194 * Returns the sysfs root path of the input device
195 *
196 */
Chris Ye3fdbfef2021-01-06 18:45:18 -0800197static std::optional<std::filesystem::path> getSysfsRootPath(const char* devicePath) {
Kim Low03ea0352020-11-06 12:45:07 -0800198 std::error_code errorCode;
199
200 // Stat the device path to get the major and minor number of the character file
201 struct stat statbuf;
202 if (stat(devicePath, &statbuf) == -1) {
203 ALOGE("Could not stat device %s due to error: %s.", devicePath, std::strerror(errno));
Chris Ye3fdbfef2021-01-06 18:45:18 -0800204 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800205 }
206
207 unsigned int major_num = major(statbuf.st_rdev);
208 unsigned int minor_num = minor(statbuf.st_rdev);
209
210 // Realpath "/sys/dev/char/{major}:{minor}" to get the sysfs path to the input event
211 auto sysfsPath = std::filesystem::path("/sys/dev/char/");
212 sysfsPath /= std::to_string(major_num) + ":" + std::to_string(minor_num);
213 sysfsPath = std::filesystem::canonical(sysfsPath, errorCode);
214
215 // Make sure nothing went wrong in call to canonical()
216 if (errorCode) {
217 ALOGW("Could not run filesystem::canonical() due to error %d : %s.", errorCode.value(),
218 errorCode.message().c_str());
Chris Ye3fdbfef2021-01-06 18:45:18 -0800219 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800220 }
221
222 // Continue to go up a directory until we reach a directory named "input"
223 while (sysfsPath != "/" && sysfsPath.filename() != "input") {
224 sysfsPath = sysfsPath.parent_path();
225 }
226
227 // Then go up one more and you will be at the sysfs root of the device
228 sysfsPath = sysfsPath.parent_path();
229
230 // Make sure we didn't reach root path and that directory actually exists
231 if (sysfsPath == "/" || !std::filesystem::exists(sysfsPath, errorCode)) {
232 if (errorCode) {
233 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
234 errorCode.message().c_str());
235 }
236
237 // Not found
Chris Ye3fdbfef2021-01-06 18:45:18 -0800238 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800239 }
240
241 return sysfsPath;
242}
243
244/**
Chris Ye3fdbfef2021-01-06 18:45:18 -0800245 * Returns the list of files under a specified path.
Kim Low03ea0352020-11-06 12:45:07 -0800246 */
Chris Ye3fdbfef2021-01-06 18:45:18 -0800247static std::vector<std::filesystem::path> allFilesInPath(const std::filesystem::path& path) {
248 std::vector<std::filesystem::path> nodes;
249 std::error_code errorCode;
250 auto iter = std::filesystem::directory_iterator(path, errorCode);
251 while (!errorCode && iter != std::filesystem::directory_iterator()) {
252 nodes.push_back(iter->path());
253 iter++;
254 }
255 return nodes;
256}
257
258/**
259 * Returns the list of files under a specified directory in a sysfs path.
260 * Example:
261 * findSysfsNodes(sysfsRootPath, SysfsClass::LEDS) will return all led nodes under "leds" directory
262 * in the sysfs path.
263 */
264static std::vector<std::filesystem::path> findSysfsNodes(const std::filesystem::path& sysfsRoot,
265 SysfsClass clazz) {
266 std::string nodeStr = NamedEnum::string(clazz);
267 std::for_each(nodeStr.begin(), nodeStr.end(),
268 [](char& c) { c = std::tolower(static_cast<unsigned char>(c)); });
269 std::vector<std::filesystem::path> nodes;
270 for (auto path = sysfsRoot; path != "/" && nodes.empty(); path = path.parent_path()) {
271 nodes = allFilesInPath(path / nodeStr);
272 }
273 return nodes;
274}
275
276static std::optional<std::array<LightColor, COLOR_NUM>> getColorIndexArray(
277 std::filesystem::path path) {
278 std::string indexStr;
279 if (!base::ReadFileToString(path, &indexStr)) {
280 return std::nullopt;
281 }
282
283 // Parse the multi color LED index file, refer to kernel docs
284 // leds/leds-class-multicolor.html
285 std::regex indexPattern("(red|green|blue)\\s(red|green|blue)\\s(red|green|blue)[\\n]");
286 std::smatch results;
287 std::array<LightColor, COLOR_NUM> colors;
288 if (!std::regex_match(indexStr, results, indexPattern)) {
289 return std::nullopt;
290 }
291
292 for (size_t i = 1; i < results.size(); i++) {
293 const auto it = LIGHT_COLORS.find(results[i].str());
294 if (it != LIGHT_COLORS.end()) {
295 // intensities.emplace(it->second, 0);
296 colors[i - 1] = it->second;
Kim Low03ea0352020-11-06 12:45:07 -0800297 }
298 }
Chris Ye3fdbfef2021-01-06 18:45:18 -0800299 return colors;
Kim Low03ea0352020-11-06 12:45:07 -0800300}
301
Michael Wrightd02c5b62014-02-10 15:10:22 -0800302// --- Global Functions ---
303
Chris Ye1b0c7342020-07-28 21:57:03 -0700304Flags<InputDeviceClass> getAbsAxisUsage(int32_t axis, Flags<InputDeviceClass> deviceClasses) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800305 // Touch devices get dibs on touch-related axes.
Chris Ye1b0c7342020-07-28 21:57:03 -0700306 if (deviceClasses.test(InputDeviceClass::TOUCH)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800307 switch (axis) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700308 case ABS_X:
309 case ABS_Y:
310 case ABS_PRESSURE:
311 case ABS_TOOL_WIDTH:
312 case ABS_DISTANCE:
313 case ABS_TILT_X:
314 case ABS_TILT_Y:
315 case ABS_MT_SLOT:
316 case ABS_MT_TOUCH_MAJOR:
317 case ABS_MT_TOUCH_MINOR:
318 case ABS_MT_WIDTH_MAJOR:
319 case ABS_MT_WIDTH_MINOR:
320 case ABS_MT_ORIENTATION:
321 case ABS_MT_POSITION_X:
322 case ABS_MT_POSITION_Y:
323 case ABS_MT_TOOL_TYPE:
324 case ABS_MT_BLOB_ID:
325 case ABS_MT_TRACKING_ID:
326 case ABS_MT_PRESSURE:
327 case ABS_MT_DISTANCE:
Chris Ye1b0c7342020-07-28 21:57:03 -0700328 return InputDeviceClass::TOUCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800329 }
330 }
331
Chris Yef59a2f42020-10-16 12:55:26 -0700332 if (deviceClasses.test(InputDeviceClass::SENSOR)) {
333 switch (axis) {
334 case ABS_X:
335 case ABS_Y:
336 case ABS_Z:
337 case ABS_RX:
338 case ABS_RY:
339 case ABS_RZ:
340 return InputDeviceClass::SENSOR;
341 }
342 }
343
Michael Wright842500e2015-03-13 17:32:02 -0700344 // External stylus gets the pressure axis
Chris Ye1b0c7342020-07-28 21:57:03 -0700345 if (deviceClasses.test(InputDeviceClass::EXTERNAL_STYLUS)) {
Michael Wright842500e2015-03-13 17:32:02 -0700346 if (axis == ABS_PRESSURE) {
Chris Ye1b0c7342020-07-28 21:57:03 -0700347 return InputDeviceClass::EXTERNAL_STYLUS;
Michael Wright842500e2015-03-13 17:32:02 -0700348 }
349 }
350
Michael Wrightd02c5b62014-02-10 15:10:22 -0800351 // Joystick devices get the rest.
Chris Ye1b0c7342020-07-28 21:57:03 -0700352 return deviceClasses & InputDeviceClass::JOYSTICK;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800353}
354
355// --- EventHub::Device ---
356
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100357EventHub::Device::Device(int fd, int32_t id, const std::string& path,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700358 const InputDeviceIdentifier& identifier)
Chris Ye989bb932020-07-04 16:18:59 -0700359 : fd(fd),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700360 id(id),
361 path(path),
362 identifier(identifier),
363 classes(0),
364 configuration(nullptr),
365 virtualKeyMap(nullptr),
366 ffEffectPlaying(false),
367 ffEffectId(-1),
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700368 associatedDevice(nullptr),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700369 controllerNumber(0),
370 enabled(true),
Chris Ye66fbac32020-07-06 20:36:43 -0700371 isVirtual(fd < 0) {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800372
373EventHub::Device::~Device() {
374 close();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800375}
376
377void EventHub::Device::close() {
378 if (fd >= 0) {
379 ::close(fd);
380 fd = -1;
381 }
382}
383
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700384status_t EventHub::Device::enable() {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100385 fd = open(path.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700386 if (fd < 0) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100387 ALOGE("could not open %s, %s\n", path.c_str(), strerror(errno));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700388 return -errno;
389 }
390 enabled = true;
391 return OK;
392}
393
394status_t EventHub::Device::disable() {
395 close();
396 enabled = false;
397 return OK;
398}
399
Chris Ye989bb932020-07-04 16:18:59 -0700400bool EventHub::Device::hasValidFd() const {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700401 return !isVirtual && enabled;
402}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800403
Chris Ye3a1e4462020-08-12 10:13:15 -0700404const std::shared_ptr<KeyCharacterMap> EventHub::Device::getKeyCharacterMap() const {
Chris Ye989bb932020-07-04 16:18:59 -0700405 return keyMap.keyCharacterMap;
406}
407
408template <std::size_t N>
409status_t EventHub::Device::readDeviceBitMask(unsigned long ioctlCode, BitArray<N>& bitArray) {
410 if (!hasValidFd()) {
411 return BAD_VALUE;
412 }
413 if ((_IOC_SIZE(ioctlCode) == 0)) {
414 ioctlCode |= _IOC(0, 0, 0, bitArray.bytes());
415 }
416
417 typename BitArray<N>::Buffer buffer;
418 status_t ret = ioctl(fd, ioctlCode, buffer.data());
419 bitArray.loadFromBuffer(buffer);
420 return ret;
421}
422
423void EventHub::Device::configureFd() {
424 // Set fd parameters with ioctl, such as key repeat, suspend block, and clock type
425 if (classes.test(InputDeviceClass::KEYBOARD)) {
426 // Disable kernel key repeat since we handle it ourselves
427 unsigned int repeatRate[] = {0, 0};
428 if (ioctl(fd, EVIOCSREP, repeatRate)) {
429 ALOGW("Unable to disable kernel key repeat for %s: %s", path.c_str(), strerror(errno));
430 }
431 }
432
433 // Tell the kernel that we want to use the monotonic clock for reporting timestamps
434 // associated with input events. This is important because the input system
435 // uses the timestamps extensively and assumes they were recorded using the monotonic
436 // clock.
437 int clockId = CLOCK_MONOTONIC;
Chris Yef59a2f42020-10-16 12:55:26 -0700438 if (classes.test(InputDeviceClass::SENSOR)) {
439 // Each new sensor event should use the same time base as
440 // SystemClock.elapsedRealtimeNanos().
441 clockId = CLOCK_BOOTTIME;
442 }
Chris Ye989bb932020-07-04 16:18:59 -0700443 bool usingClockIoctl = !ioctl(fd, EVIOCSCLOCKID, &clockId);
444 ALOGI("usingClockIoctl=%s", toString(usingClockIoctl));
445}
446
447bool EventHub::Device::hasKeycodeLocked(int keycode) const {
448 if (!keyMap.haveKeyLayout()) {
449 return false;
450 }
451
452 std::vector<int32_t> scanCodes;
453 keyMap.keyLayoutMap->findScanCodesForKey(keycode, &scanCodes);
454 const size_t N = scanCodes.size();
455 for (size_t i = 0; i < N && i <= KEY_MAX; i++) {
456 int32_t sc = scanCodes[i];
457 if (sc >= 0 && sc <= KEY_MAX && keyBitmask.test(sc)) {
458 return true;
459 }
460 }
461
462 return false;
463}
464
465void EventHub::Device::loadConfigurationLocked() {
466 configurationFile =
467 getInputDeviceConfigurationFilePathByDeviceIdentifier(identifier,
468 InputDeviceConfigurationFileType::
469 CONFIGURATION);
470 if (configurationFile.empty()) {
471 ALOGD("No input device configuration file found for device '%s'.", identifier.name.c_str());
472 } else {
Siarhei Vishniakou4d9f9772020-09-02 22:28:29 -0500473 android::base::Result<std::unique_ptr<PropertyMap>> propertyMap =
474 PropertyMap::load(configurationFile.c_str());
475 if (!propertyMap.ok()) {
Chris Ye989bb932020-07-04 16:18:59 -0700476 ALOGE("Error loading input device configuration file for device '%s'. "
477 "Using default configuration.",
478 identifier.name.c_str());
Siarhei Vishniakoud549b252020-08-11 11:25:26 -0500479 } else {
Siarhei Vishniakou4d9f9772020-09-02 22:28:29 -0500480 configuration = std::move(*propertyMap);
Chris Ye989bb932020-07-04 16:18:59 -0700481 }
482 }
483}
484
485bool EventHub::Device::loadVirtualKeyMapLocked() {
486 // The virtual key map is supplied by the kernel as a system board property file.
487 std::string propPath = "/sys/board_properties/virtualkeys.";
488 propPath += identifier.getCanonicalName();
489 if (access(propPath.c_str(), R_OK)) {
490 return false;
491 }
492 virtualKeyMap = VirtualKeyMap::load(propPath);
493 return virtualKeyMap != nullptr;
494}
495
496status_t EventHub::Device::loadKeyMapLocked() {
Siarhei Vishniakoud549b252020-08-11 11:25:26 -0500497 return keyMap.load(identifier, configuration.get());
Chris Ye989bb932020-07-04 16:18:59 -0700498}
499
500bool EventHub::Device::isExternalDeviceLocked() {
501 if (configuration) {
502 bool value;
503 if (configuration->tryGetProperty(String8("device.internal"), value)) {
504 return !value;
505 }
506 }
507 return identifier.bus == BUS_USB || identifier.bus == BUS_BLUETOOTH;
508}
509
510bool EventHub::Device::deviceHasMicLocked() {
511 if (configuration) {
512 bool value;
513 if (configuration->tryGetProperty(String8("audio.mic"), value)) {
514 return value;
515 }
516 }
517 return false;
518}
519
520void EventHub::Device::setLedStateLocked(int32_t led, bool on) {
521 int32_t sc;
522 if (hasValidFd() && mapLed(led, &sc) != NAME_NOT_FOUND) {
523 struct input_event ev;
524 ev.time.tv_sec = 0;
525 ev.time.tv_usec = 0;
526 ev.type = EV_LED;
527 ev.code = sc;
528 ev.value = on ? 1 : 0;
529
530 ssize_t nWrite;
531 do {
532 nWrite = write(fd, &ev, sizeof(struct input_event));
533 } while (nWrite == -1 && errno == EINTR);
534 }
535}
536
537void EventHub::Device::setLedForControllerLocked() {
538 for (int i = 0; i < MAX_CONTROLLER_LEDS; i++) {
539 setLedStateLocked(ALED_CONTROLLER_1 + i, controllerNumber == i + 1);
540 }
541}
542
543status_t EventHub::Device::mapLed(int32_t led, int32_t* outScanCode) const {
544 if (!keyMap.haveKeyLayout()) {
545 return NAME_NOT_FOUND;
546 }
547
548 int32_t scanCode;
549 if (keyMap.keyLayoutMap->findScanCodeForLed(led, &scanCode) != NAME_NOT_FOUND) {
550 if (scanCode >= 0 && scanCode <= LED_MAX && ledBitmask.test(scanCode)) {
551 *outScanCode = scanCode;
552 return NO_ERROR;
553 }
554 }
555 return NAME_NOT_FOUND;
556}
557
Chris Ye3fdbfef2021-01-06 18:45:18 -0800558// Check the sysfs path for any input device batteries, returns true if battery found.
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700559bool EventHub::AssociatedDevice::configureBatteryLocked() {
Chris Yee2b1e5c2021-03-10 22:45:12 -0800560 nextBatteryId = 0;
561 // Check if device has any battery.
562 const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::POWER_SUPPLY);
563 for (const auto& nodePath : paths) {
564 RawBatteryInfo info;
565 info.id = ++nextBatteryId;
566 info.path = nodePath;
567 info.name = nodePath.filename();
568
569 // Scan the path for all the files
570 // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt
571 const auto& files = allFilesInPath(nodePath);
572 for (const auto& file : files) {
573 const auto it = BATTERY_CLASSES.find(file.filename().string());
574 if (it != BATTERY_CLASSES.end()) {
575 info.flags |= it->second;
576 }
577 }
578 batteryInfos.insert_or_assign(info.id, info);
579 ALOGD("configureBatteryLocked rawBatteryId %d name %s", info.id, info.name.c_str());
Chris Ye3fdbfef2021-01-06 18:45:18 -0800580 }
Chris Yee2b1e5c2021-03-10 22:45:12 -0800581 return !batteryInfos.empty();
Chris Ye3fdbfef2021-01-06 18:45:18 -0800582}
583
584// Check the sysfs path for any input device lights, returns true if lights found.
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700585bool EventHub::AssociatedDevice::configureLightsLocked() {
Chris Yee2b1e5c2021-03-10 22:45:12 -0800586 nextLightId = 0;
Chris Ye3fdbfef2021-01-06 18:45:18 -0800587 // Check if device has any lights.
Chris Yee2b1e5c2021-03-10 22:45:12 -0800588 const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::LEDS);
Chris Ye3fdbfef2021-01-06 18:45:18 -0800589 for (const auto& nodePath : paths) {
590 RawLightInfo info;
591 info.id = ++nextLightId;
592 info.path = nodePath;
593 info.name = nodePath.filename();
594 info.maxBrightness = std::nullopt;
595 size_t nameStart = info.name.rfind(":");
596 if (nameStart != std::string::npos) {
597 // Trim the name to color name
598 info.name = info.name.substr(nameStart + 1);
599 // Set InputLightClass flag for colors
600 const auto it = LIGHT_CLASSES.find(info.name);
601 if (it != LIGHT_CLASSES.end()) {
602 info.flags |= it->second;
603 }
604 }
605 // Scan the path for all the files
606 // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt
607 const auto& files = allFilesInPath(nodePath);
608 for (const auto& file : files) {
609 const auto it = LIGHT_CLASSES.find(file.filename().string());
610 if (it != LIGHT_CLASSES.end()) {
611 info.flags |= it->second;
612 // If the node has maximum brightness, read it
613 if (it->second == InputLightClass::MAX_BRIGHTNESS) {
614 std::string str;
615 if (base::ReadFileToString(file, &str)) {
616 info.maxBrightness = std::stoi(str);
617 }
618 }
619 }
620 }
621 lightInfos.insert_or_assign(info.id, info);
Chris Yee2b1e5c2021-03-10 22:45:12 -0800622 ALOGD("configureLightsLocked rawLightId %d name %s", info.id, info.name.c_str());
Chris Ye3fdbfef2021-01-06 18:45:18 -0800623 }
624 return !lightInfos.empty();
625}
626
Siarhei Vishniakou7a522bf2019-09-24 12:46:29 +0100627/**
628 * Get the capabilities for the current process.
629 * Crashes the system if unable to create / check / destroy the capabilities object.
630 */
631class Capabilities final {
632public:
633 explicit Capabilities() {
634 mCaps = cap_get_proc();
635 LOG_ALWAYS_FATAL_IF(mCaps == nullptr, "Could not get capabilities of the current process");
636 }
637
638 /**
639 * Check whether the current process has a specific capability
640 * in the set of effective capabilities.
641 * Return CAP_SET if the process has the requested capability
642 * Return CAP_CLEAR otherwise.
643 */
644 cap_flag_value_t checkEffectiveCapability(cap_value_t capability) {
645 cap_flag_value_t value;
646 const int result = cap_get_flag(mCaps, capability, CAP_EFFECTIVE, &value);
647 LOG_ALWAYS_FATAL_IF(result == -1, "Could not obtain the requested capability");
648 return value;
649 }
650
651 ~Capabilities() {
652 const int result = cap_free(mCaps);
653 LOG_ALWAYS_FATAL_IF(result == -1, "Could not release the capabilities structure");
654 }
655
656private:
657 cap_t mCaps;
658};
659
660static void ensureProcessCanBlockSuspend() {
661 Capabilities capabilities;
662 const bool canBlockSuspend =
663 capabilities.checkEffectiveCapability(CAP_BLOCK_SUSPEND) == CAP_SET;
664 LOG_ALWAYS_FATAL_IF(!canBlockSuspend,
665 "Input must be able to block suspend to properly process events");
666}
667
Michael Wrightd02c5b62014-02-10 15:10:22 -0800668// --- EventHub ---
669
Michael Wrightd02c5b62014-02-10 15:10:22 -0800670const int EventHub::EPOLL_MAX_EVENTS;
671
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700672EventHub::EventHub(void)
673 : mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD),
674 mNextDeviceId(1),
675 mControllerNumbers(),
Michael Wrightd02c5b62014-02-10 15:10:22 -0800676 mNeedToSendFinishedDeviceScan(false),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700677 mNeedToReopenDevices(false),
678 mNeedToScanDevices(true),
679 mPendingEventCount(0),
680 mPendingEventIndex(0),
681 mPendingINotify(false) {
Siarhei Vishniakou7a522bf2019-09-24 12:46:29 +0100682 ensureProcessCanBlockSuspend();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800683
Nick Kralevichfcf1b2b2018-12-15 11:59:30 -0800684 mEpollFd = epoll_create1(EPOLL_CLOEXEC);
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800685 LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance: %s", strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -0800686
687 mINotifyFd = inotify_init();
Usama Arif78eb9752021-06-03 16:44:09 +0100688
689 std::error_code errorCode;
690 bool isDeviceInotifyAdded = false;
691 if (std::filesystem::exists(DEVICE_INPUT_PATH, errorCode)) {
692 addDeviceInputInotify();
Philip Quinn39b81682019-01-09 22:20:39 -0800693 } else {
Usama Arif78eb9752021-06-03 16:44:09 +0100694 addDeviceInotify();
695 isDeviceInotifyAdded = true;
696 if (errorCode) {
697 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
698 errorCode.message().c_str());
699 }
700 }
701
702 if (isV4lScanningEnabled() && !isDeviceInotifyAdded) {
703 addDeviceInotify();
704 } else {
Philip Quinn39b81682019-01-09 22:20:39 -0800705 ALOGI("Video device scanning disabled");
706 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800707
Siarhei Vishniakou2d0e9482019-09-24 12:52:47 +0100708 struct epoll_event eventItem = {};
709 eventItem.events = EPOLLIN | EPOLLWAKEUP;
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -0700710 eventItem.data.fd = mINotifyFd;
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800711 int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800712 LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno);
713
714 int wakeFds[2];
715 result = pipe(wakeFds);
716 LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno);
717
718 mWakeReadPipeFd = wakeFds[0];
719 mWakeWritePipeFd = wakeFds[1];
720
721 result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
722 LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700723 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800724
725 result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
726 LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700727 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800728
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -0700729 eventItem.data.fd = mWakeReadPipeFd;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800730 result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
731 LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700732 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800733}
734
735EventHub::~EventHub(void) {
736 closeAllDevicesLocked();
737
Michael Wrightd02c5b62014-02-10 15:10:22 -0800738 ::close(mEpollFd);
739 ::close(mINotifyFd);
740 ::close(mWakeReadPipeFd);
741 ::close(mWakeWritePipeFd);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800742}
743
Usama Arif78eb9752021-06-03 16:44:09 +0100744/**
745 * On devices that don't have any input devices (like some development boards), the /dev/input
746 * directory will be absent. However, the user may still plug in an input device at a later time.
747 * Add watch for contents of /dev/input only when /dev/input appears.
748 */
749void EventHub::addDeviceInputInotify() {
750 mDeviceInputWd = inotify_add_watch(mINotifyFd, DEVICE_INPUT_PATH, IN_DELETE | IN_CREATE);
751 LOG_ALWAYS_FATAL_IF(mDeviceInputWd < 0, "Could not register INotify for %s: %s",
752 DEVICE_INPUT_PATH, strerror(errno));
753}
754
755void EventHub::addDeviceInotify() {
756 mDeviceWd = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
757 LOG_ALWAYS_FATAL_IF(mDeviceWd < 0, "Could not register INotify for %s: %s", DEVICE_PATH,
758 strerror(errno));
759}
760
Michael Wrightd02c5b62014-02-10 15:10:22 -0800761InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000762 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800763 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700764 return device != nullptr ? device->identifier : InputDeviceIdentifier();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800765}
766
Chris Ye1b0c7342020-07-28 21:57:03 -0700767Flags<InputDeviceClass> EventHub::getDeviceClasses(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000768 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800769 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700770 return device != nullptr ? device->classes : Flags<InputDeviceClass>(0);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800771}
772
773int32_t EventHub::getDeviceControllerNumber(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000774 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800775 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700776 return device != nullptr ? device->controllerNumber : 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800777}
778
779void EventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const {
Chris Ye87143712020-11-10 05:05:58 +0000780 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800781 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700782 if (device != nullptr && device->configuration) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800783 *outConfiguration = *device->configuration;
784 } else {
785 outConfiguration->clear();
786 }
787}
788
789status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700790 RawAbsoluteAxisInfo* outAxisInfo) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800791 outAxisInfo->clear();
792
793 if (axis >= 0 && axis <= ABS_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000794 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800795
796 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700797 if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800798 struct input_absinfo info;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700799 if (ioctl(device->fd, EVIOCGABS(axis), &info)) {
800 ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis,
801 device->identifier.name.c_str(), device->fd, errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800802 return -errno;
803 }
804
805 if (info.minimum != info.maximum) {
806 outAxisInfo->valid = true;
807 outAxisInfo->minValue = info.minimum;
808 outAxisInfo->maxValue = info.maximum;
809 outAxisInfo->flat = info.flat;
810 outAxisInfo->fuzz = info.fuzz;
811 outAxisInfo->resolution = info.resolution;
812 }
813 return OK;
814 }
815 }
816 return -1;
817}
818
819bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
820 if (axis >= 0 && axis <= REL_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000821 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800822 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700823 return device != nullptr ? device->relBitmask.test(axis) : false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800824 }
825 return false;
826}
827
828bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
Chris Ye87143712020-11-10 05:05:58 +0000829 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800830
Chris Ye989bb932020-07-04 16:18:59 -0700831 Device* device = getDeviceLocked(deviceId);
832 return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr
833 ? device->propBitmask.test(property)
834 : false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800835}
836
Chris Yef59a2f42020-10-16 12:55:26 -0700837bool EventHub::hasMscEvent(int32_t deviceId, int mscEvent) const {
838 std::scoped_lock _l(mLock);
839
840 Device* device = getDeviceLocked(deviceId);
841 return mscEvent >= 0 && mscEvent <= MSC_MAX && device != nullptr
842 ? device->mscBitmask.test(mscEvent)
843 : false;
844}
845
Michael Wrightd02c5b62014-02-10 15:10:22 -0800846int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
847 if (scanCode >= 0 && scanCode <= KEY_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000848 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800849
850 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700851 if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) {
852 if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {
853 return device->keyState.test(scanCode) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800854 }
855 }
856 }
857 return AKEY_STATE_UNKNOWN;
858}
859
860int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
Chris Ye87143712020-11-10 05:05:58 +0000861 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800862
863 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700864 if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800865 std::vector<int32_t> scanCodes;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800866 device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes);
867 if (scanCodes.size() != 0) {
Chris Ye66fbac32020-07-06 20:36:43 -0700868 if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800869 for (size_t i = 0; i < scanCodes.size(); i++) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800870 int32_t sc = scanCodes[i];
Chris Ye66fbac32020-07-06 20:36:43 -0700871 if (sc >= 0 && sc <= KEY_MAX && device->keyState.test(sc)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800872 return AKEY_STATE_DOWN;
873 }
874 }
875 return AKEY_STATE_UP;
876 }
877 }
878 }
879 return AKEY_STATE_UNKNOWN;
880}
881
882int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
883 if (sw >= 0 && sw <= SW_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000884 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800885
886 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700887 if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) {
888 if (device->readDeviceBitMask(EVIOCGSW(0), device->swState) >= 0) {
889 return device->swState.test(sw) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800890 }
891 }
892 }
893 return AKEY_STATE_UNKNOWN;
894}
895
896status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const {
897 *outValue = 0;
898
899 if (axis >= 0 && axis <= ABS_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000900 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800901
902 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700903 if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800904 struct input_absinfo info;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700905 if (ioctl(device->fd, EVIOCGABS(axis), &info)) {
906 ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis,
907 device->identifier.name.c_str(), device->fd, errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800908 return -errno;
909 }
910
911 *outValue = info.value;
912 return OK;
913 }
914 }
915 return -1;
916}
917
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700918bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
919 uint8_t* outFlags) const {
Chris Ye87143712020-11-10 05:05:58 +0000920 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800921
922 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700923 if (device != nullptr && device->keyMap.haveKeyLayout()) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800924 std::vector<int32_t> scanCodes;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800925 for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) {
926 scanCodes.clear();
927
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700928 status_t err = device->keyMap.keyLayoutMap->findScanCodesForKey(keyCodes[codeIndex],
929 &scanCodes);
930 if (!err) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800931 // check the possible scan codes identified by the layout map against the
932 // map of codes actually emitted by the driver
933 for (size_t sc = 0; sc < scanCodes.size(); sc++) {
Chris Ye66fbac32020-07-06 20:36:43 -0700934 if (device->keyBitmask.test(scanCodes[sc])) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800935 outFlags[codeIndex] = 1;
936 break;
937 }
938 }
939 }
940 }
941 return true;
942 }
943 return false;
944}
945
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700946status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
947 int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
Chris Ye87143712020-11-10 05:05:58 +0000948 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800949 Device* device = getDeviceLocked(deviceId);
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700950 status_t status = NAME_NOT_FOUND;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800951
Chris Ye66fbac32020-07-06 20:36:43 -0700952 if (device != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800953 // Check the key character map first.
Chris Ye3a1e4462020-08-12 10:13:15 -0700954 const std::shared_ptr<KeyCharacterMap> kcm = device->getKeyCharacterMap();
955 if (kcm) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800956 if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {
957 *outFlags = 0;
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700958 status = NO_ERROR;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800959 }
960 }
961
962 // Check the key layout next.
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700963 if (status != NO_ERROR && device->keyMap.haveKeyLayout()) {
Siarhei Vishniakou592bac22018-11-08 19:42:38 -0800964 if (!device->keyMap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags)) {
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700965 status = NO_ERROR;
966 }
967 }
968
969 if (status == NO_ERROR) {
Chris Ye3a1e4462020-08-12 10:13:15 -0700970 if (kcm) {
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700971 kcm->tryRemapKey(*outKeycode, metaState, outKeycode, outMetaState);
972 } else {
973 *outMetaState = metaState;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800974 }
975 }
976 }
977
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -0700978 if (status != NO_ERROR) {
979 *outKeycode = 0;
980 *outFlags = 0;
981 *outMetaState = metaState;
982 }
983
984 return status;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800985}
986
987status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const {
Chris Ye87143712020-11-10 05:05:58 +0000988 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800989 Device* device = getDeviceLocked(deviceId);
990
Chris Ye66fbac32020-07-06 20:36:43 -0700991 if (device != nullptr && device->keyMap.haveKeyLayout()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800992 status_t err = device->keyMap.keyLayoutMap->mapAxis(scanCode, outAxisInfo);
993 if (err == NO_ERROR) {
994 return NO_ERROR;
995 }
996 }
997
998 return NAME_NOT_FOUND;
999}
1000
Chris Yef59a2f42020-10-16 12:55:26 -07001001base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId,
1002 int32_t absCode) {
1003 std::scoped_lock _l(mLock);
1004 Device* device = getDeviceLocked(deviceId);
1005
1006 if (device != nullptr && device->keyMap.haveKeyLayout()) {
1007 return device->keyMap.keyLayoutMap->mapSensor(absCode);
1008 }
1009 return Errorf("Device not found or device has no key layout.");
1010}
1011
Chris Yee2b1e5c2021-03-10 22:45:12 -08001012// Gets the battery info map from battery ID to RawBatteryInfo of the miscellaneous device
1013// associated with the device ID. Returns an empty map if no miscellaneous device found.
1014const std::unordered_map<int32_t, RawBatteryInfo>& EventHub::getBatteryInfoLocked(
1015 int32_t deviceId) const {
1016 static const std::unordered_map<int32_t, RawBatteryInfo> EMPTY_BATTERY_INFO = {};
1017 Device* device = getDeviceLocked(deviceId);
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001018 if (device == nullptr || !device->associatedDevice) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001019 return EMPTY_BATTERY_INFO;
1020 }
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001021 return device->associatedDevice->batteryInfos;
Chris Yee2b1e5c2021-03-10 22:45:12 -08001022}
1023
1024const std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) {
1025 std::scoped_lock _l(mLock);
1026 std::vector<int32_t> batteryIds;
1027
1028 for (const auto [id, info] : getBatteryInfoLocked(deviceId)) {
1029 batteryIds.push_back(id);
1030 }
1031
1032 return batteryIds;
1033}
1034
1035std::optional<RawBatteryInfo> EventHub::getRawBatteryInfo(int32_t deviceId, int32_t batteryId) {
1036 std::scoped_lock _l(mLock);
1037
1038 const auto infos = getBatteryInfoLocked(deviceId);
1039
1040 auto it = infos.find(batteryId);
1041 if (it != infos.end()) {
1042 return it->second;
1043 }
1044
1045 return std::nullopt;
1046}
1047
1048// Gets the light info map from light ID to RawLightInfo of the miscellaneous device associated
1049// with the deivice ID. Returns an empty map if no miscellaneous device found.
1050const std::unordered_map<int32_t, RawLightInfo>& EventHub::getLightInfoLocked(
1051 int32_t deviceId) const {
1052 static const std::unordered_map<int32_t, RawLightInfo> EMPTY_LIGHT_INFO = {};
1053 Device* device = getDeviceLocked(deviceId);
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001054 if (device == nullptr || !device->associatedDevice) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001055 return EMPTY_LIGHT_INFO;
1056 }
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001057 return device->associatedDevice->lightInfos;
Chris Yee2b1e5c2021-03-10 22:45:12 -08001058}
1059
Chris Ye3fdbfef2021-01-06 18:45:18 -08001060const std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) {
1061 std::scoped_lock _l(mLock);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001062 std::vector<int32_t> lightIds;
1063
Chris Yee2b1e5c2021-03-10 22:45:12 -08001064 for (const auto [id, info] : getLightInfoLocked(deviceId)) {
1065 lightIds.push_back(id);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001066 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001067
Chris Ye3fdbfef2021-01-06 18:45:18 -08001068 return lightIds;
1069}
1070
1071std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) {
1072 std::scoped_lock _l(mLock);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001073
Chris Yee2b1e5c2021-03-10 22:45:12 -08001074 const auto infos = getLightInfoLocked(deviceId);
1075
1076 auto it = infos.find(lightId);
1077 if (it != infos.end()) {
1078 return it->second;
Chris Ye3fdbfef2021-01-06 18:45:18 -08001079 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001080
Chris Ye3fdbfef2021-01-06 18:45:18 -08001081 return std::nullopt;
1082}
1083
1084std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t lightId) {
1085 std::scoped_lock _l(mLock);
1086
Chris Yee2b1e5c2021-03-10 22:45:12 -08001087 const auto infos = getLightInfoLocked(deviceId);
1088 auto it = infos.find(lightId);
1089 if (it == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001090 return std::nullopt;
1091 }
1092 std::string buffer;
1093 if (!base::ReadFileToString(it->second.path / LIGHT_NODES.at(InputLightClass::BRIGHTNESS),
1094 &buffer)) {
1095 return std::nullopt;
1096 }
1097 return std::stoi(buffer);
1098}
1099
1100std::optional<std::unordered_map<LightColor, int32_t>> EventHub::getLightIntensities(
1101 int32_t deviceId, int32_t lightId) {
1102 std::scoped_lock _l(mLock);
1103
Chris Yee2b1e5c2021-03-10 22:45:12 -08001104 const auto infos = getLightInfoLocked(deviceId);
1105 auto lightIt = infos.find(lightId);
1106 if (lightIt == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001107 return std::nullopt;
1108 }
1109
1110 auto ret =
1111 getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX));
1112
1113 if (!ret.has_value()) {
1114 return std::nullopt;
1115 }
1116 std::array<LightColor, COLOR_NUM> colors = ret.value();
1117
1118 std::string intensityStr;
1119 if (!base::ReadFileToString(lightIt->second.path /
1120 LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY),
1121 &intensityStr)) {
1122 return std::nullopt;
1123 }
1124
1125 // Intensity node outputs 3 color values
1126 std::regex intensityPattern("([0-9]+)\\s([0-9]+)\\s([0-9]+)[\\n]");
1127 std::smatch results;
1128
1129 if (!std::regex_match(intensityStr, results, intensityPattern)) {
1130 return std::nullopt;
1131 }
1132 std::unordered_map<LightColor, int32_t> intensities;
1133 for (size_t i = 1; i < results.size(); i++) {
1134 int value = std::stoi(results[i].str());
1135 intensities.emplace(colors[i - 1], value);
1136 }
1137 return intensities;
1138}
1139
1140void EventHub::setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) {
1141 std::scoped_lock _l(mLock);
1142
Chris Yee2b1e5c2021-03-10 22:45:12 -08001143 const auto infos = getLightInfoLocked(deviceId);
1144 auto lightIt = infos.find(lightId);
1145 if (lightIt == infos.end()) {
1146 ALOGE("%s lightId %d not found ", __func__, lightId);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001147 return;
1148 }
1149
1150 if (!base::WriteStringToFile(std::to_string(brightness),
1151 lightIt->second.path /
1152 LIGHT_NODES.at(InputLightClass::BRIGHTNESS))) {
1153 ALOGE("Can not write to file, error: %s", strerror(errno));
1154 }
1155}
1156
1157void EventHub::setLightIntensities(int32_t deviceId, int32_t lightId,
1158 std::unordered_map<LightColor, int32_t> intensities) {
1159 std::scoped_lock _l(mLock);
1160
Chris Yee2b1e5c2021-03-10 22:45:12 -08001161 const auto infos = getLightInfoLocked(deviceId);
1162 auto lightIt = infos.find(lightId);
1163 if (lightIt == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001164 ALOGE("Light Id %d does not exist.", lightId);
1165 return;
1166 }
1167
1168 auto ret =
1169 getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX));
1170
1171 if (!ret.has_value()) {
1172 return;
1173 }
1174 std::array<LightColor, COLOR_NUM> colors = ret.value();
1175
1176 std::string rgbStr;
1177 for (size_t i = 0; i < COLOR_NUM; i++) {
1178 auto it = intensities.find(colors[i]);
1179 if (it != intensities.end()) {
1180 rgbStr += std::to_string(it->second);
1181 // Insert space between colors
1182 if (i < COLOR_NUM - 1) {
1183 rgbStr += " ";
1184 }
1185 }
1186 }
1187 // Append new line
1188 rgbStr += "\n";
1189
1190 if (!base::WriteStringToFile(rgbStr,
1191 lightIt->second.path /
1192 LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY))) {
1193 ALOGE("Can not write to file, error: %s", strerror(errno));
1194 }
1195}
1196
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001197void EventHub::setExcludedDevices(const std::vector<std::string>& devices) {
Chris Ye87143712020-11-10 05:05:58 +00001198 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001199
1200 mExcludedDevices = devices;
1201}
1202
1203bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
Chris Ye87143712020-11-10 05:05:58 +00001204 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001205 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001206 if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {
1207 return device->keyBitmask.test(scanCode);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001208 }
1209 return false;
1210}
1211
1212bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
Chris Ye87143712020-11-10 05:05:58 +00001213 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001214 Device* device = getDeviceLocked(deviceId);
1215 int32_t sc;
Chris Ye989bb932020-07-04 16:18:59 -07001216 if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) {
Chris Ye66fbac32020-07-06 20:36:43 -07001217 return device->ledBitmask.test(sc);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001218 }
1219 return false;
1220}
1221
1222void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) {
Chris Ye87143712020-11-10 05:05:58 +00001223 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001224 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -07001225 if (device != nullptr && device->hasValidFd()) {
1226 device->setLedStateLocked(led, on);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001227 }
1228}
1229
1230void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001231 std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001232 outVirtualKeys.clear();
1233
Chris Ye87143712020-11-10 05:05:58 +00001234 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001235 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001236 if (device != nullptr && device->virtualKeyMap) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001237 const std::vector<VirtualKeyDefinition> virtualKeys =
1238 device->virtualKeyMap->getVirtualKeys();
1239 outVirtualKeys.insert(outVirtualKeys.end(), virtualKeys.begin(), virtualKeys.end());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001240 }
1241}
1242
Chris Ye3a1e4462020-08-12 10:13:15 -07001243const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +00001244 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001245 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001246 if (device != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001247 return device->getKeyCharacterMap();
1248 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001249 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001250}
1251
Chris Ye3a1e4462020-08-12 10:13:15 -07001252bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId, std::shared_ptr<KeyCharacterMap> map) {
Chris Ye87143712020-11-10 05:05:58 +00001253 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001254 Device* device = getDeviceLocked(deviceId);
Philip Junkerb60596f2021-12-10 18:39:42 +01001255 if (device == nullptr || map == nullptr || device->keyMap.keyCharacterMap == nullptr) {
1256 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001257 }
Philip Junkerb60596f2021-12-10 18:39:42 +01001258 device->keyMap.keyCharacterMap->combine(*map);
1259 return true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001260}
1261
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001262static std::string generateDescriptor(InputDeviceIdentifier& identifier) {
1263 std::string rawDescriptor;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001264 rawDescriptor += StringPrintf(":%04x:%04x:", identifier.vendor, identifier.product);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001265 // TODO add handling for USB devices to not uniqueify kbs that show up twice
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001266 if (!identifier.uniqueId.empty()) {
1267 rawDescriptor += "uniqueId:";
1268 rawDescriptor += identifier.uniqueId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001269 } else if (identifier.nonce != 0) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001270 rawDescriptor += StringPrintf("nonce:%04x", identifier.nonce);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001271 }
1272
1273 if (identifier.vendor == 0 && identifier.product == 0) {
1274 // If we don't know the vendor and product id, then the device is probably
1275 // built-in so we need to rely on other information to uniquely identify
1276 // the input device. Usually we try to avoid relying on the device name or
1277 // location but for built-in input device, they are unlikely to ever change.
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001278 if (!identifier.name.empty()) {
1279 rawDescriptor += "name:";
1280 rawDescriptor += identifier.name;
1281 } else if (!identifier.location.empty()) {
1282 rawDescriptor += "location:";
1283 rawDescriptor += identifier.location;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001284 }
1285 }
1286 identifier.descriptor = sha1(rawDescriptor);
1287 return rawDescriptor;
1288}
1289
1290void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) {
1291 // Compute a device descriptor that uniquely identifies the device.
1292 // The descriptor is assumed to be a stable identifier. Its value should not
1293 // change between reboots, reconnections, firmware updates or new releases
1294 // of Android. In practice we sometimes get devices that cannot be uniquely
1295 // identified. In this case we enforce uniqueness between connected devices.
1296 // Ideally, we also want the descriptor to be short and relatively opaque.
1297
1298 identifier.nonce = 0;
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001299 std::string rawDescriptor = generateDescriptor(identifier);
1300 if (identifier.uniqueId.empty()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001301 // If it didn't have a unique id check for conflicts and enforce
1302 // uniqueness if necessary.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001303 while (getDeviceByDescriptorLocked(identifier.descriptor) != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001304 identifier.nonce++;
1305 rawDescriptor = generateDescriptor(identifier);
1306 }
1307 }
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001308 ALOGV("Created descriptor: raw=%s, cooked=%s", rawDescriptor.c_str(),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001309 identifier.descriptor.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001310}
1311
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001312void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) {
Chris Ye87143712020-11-10 05:05:58 +00001313 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001314 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001315 if (device != nullptr && device->hasValidFd()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001316 ff_effect effect;
1317 memset(&effect, 0, sizeof(effect));
1318 effect.type = FF_RUMBLE;
1319 effect.id = device->ffEffectId;
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001320 // evdev FF_RUMBLE effect only supports two channels of vibration.
Chris Ye6393a262020-08-04 19:41:36 -07001321 effect.u.rumble.strong_magnitude = element.getMagnitude(FF_STRONG_MAGNITUDE_CHANNEL_IDX);
1322 effect.u.rumble.weak_magnitude = element.getMagnitude(FF_WEAK_MAGNITUDE_CHANNEL_IDX);
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001323 effect.replay.length = element.duration.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001324 effect.replay.delay = 0;
1325 if (ioctl(device->fd, EVIOCSFF, &effect)) {
1326 ALOGW("Could not upload force feedback effect to device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001327 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001328 return;
1329 }
1330 device->ffEffectId = effect.id;
1331
1332 struct input_event ev;
1333 ev.time.tv_sec = 0;
1334 ev.time.tv_usec = 0;
1335 ev.type = EV_FF;
1336 ev.code = device->ffEffectId;
1337 ev.value = 1;
1338 if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
1339 ALOGW("Could not start force feedback effect on device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001340 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001341 return;
1342 }
1343 device->ffEffectPlaying = true;
1344 }
1345}
1346
1347void EventHub::cancelVibrate(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00001348 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001349 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001350 if (device != nullptr && device->hasValidFd()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001351 if (device->ffEffectPlaying) {
1352 device->ffEffectPlaying = false;
1353
1354 struct input_event ev;
1355 ev.time.tv_sec = 0;
1356 ev.time.tv_usec = 0;
1357 ev.type = EV_FF;
1358 ev.code = device->ffEffectId;
1359 ev.value = 0;
1360 if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
1361 ALOGW("Could not stop force feedback effect on device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001362 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001363 return;
1364 }
1365 }
1366 }
1367}
1368
Chris Ye87143712020-11-10 05:05:58 +00001369std::vector<int32_t> EventHub::getVibratorIds(int32_t deviceId) {
1370 std::scoped_lock _l(mLock);
1371 std::vector<int32_t> vibrators;
1372 Device* device = getDeviceLocked(deviceId);
1373 if (device != nullptr && device->hasValidFd() &&
1374 device->classes.test(InputDeviceClass::VIBRATOR)) {
1375 vibrators.push_back(FF_STRONG_MAGNITUDE_CHANNEL_IDX);
1376 vibrators.push_back(FF_WEAK_MAGNITUDE_CHANNEL_IDX);
1377 }
1378 return vibrators;
1379}
1380
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001381EventHub::Device* EventHub::getDeviceByDescriptorLocked(const std::string& descriptor) const {
Chris Ye989bb932020-07-04 16:18:59 -07001382 for (const auto& [id, device] : mDevices) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001383 if (descriptor == device->identifier.descriptor) {
Chris Ye989bb932020-07-04 16:18:59 -07001384 return device.get();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001385 }
1386 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001387 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001388}
1389
1390EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const {
Prabir Pradhancae4b3a2019-02-05 18:51:32 -08001391 if (deviceId == ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001392 deviceId = mBuiltInKeyboardId;
1393 }
Chris Ye989bb932020-07-04 16:18:59 -07001394 const auto& it = mDevices.find(deviceId);
1395 return it != mDevices.end() ? it->second.get() : nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001396}
1397
Chris Ye8594e192020-07-14 10:34:06 -07001398EventHub::Device* EventHub::getDeviceByPathLocked(const std::string& devicePath) const {
Chris Ye989bb932020-07-04 16:18:59 -07001399 for (const auto& [id, device] : mDevices) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001400 if (device->path == devicePath) {
Chris Ye989bb932020-07-04 16:18:59 -07001401 return device.get();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001402 }
1403 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001404 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001405}
1406
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001407/**
1408 * The file descriptor could be either input device, or a video device (associated with a
1409 * specific input device). Check both cases here, and return the device that this event
1410 * belongs to. Caller can compare the fd's once more to determine event type.
1411 * Looks through all input devices, and only attached video devices. Unattached video
1412 * devices are ignored.
1413 */
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001414EventHub::Device* EventHub::getDeviceByFdLocked(int fd) const {
Chris Ye989bb932020-07-04 16:18:59 -07001415 for (const auto& [id, device] : mDevices) {
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001416 if (device->fd == fd) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001417 // This is an input device event
Chris Ye989bb932020-07-04 16:18:59 -07001418 return device.get();
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001419 }
1420 if (device->videoDevice && device->videoDevice->getFd() == fd) {
1421 // This is a video device event
Chris Ye989bb932020-07-04 16:18:59 -07001422 return device.get();
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001423 }
1424 }
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001425 // We do not check mUnattachedVideoDevices here because they should not participate in epoll,
1426 // and therefore should never be looked up by fd.
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001427 return nullptr;
1428}
1429
Chris Yee2b1e5c2021-03-10 22:45:12 -08001430std::optional<int32_t> EventHub::getBatteryCapacity(int32_t deviceId, int32_t batteryId) const {
Kim Low03ea0352020-11-06 12:45:07 -08001431 std::scoped_lock _l(mLock);
Kim Low03ea0352020-11-06 12:45:07 -08001432
Chris Yee2b1e5c2021-03-10 22:45:12 -08001433 const auto infos = getBatteryInfoLocked(deviceId);
1434 auto it = infos.find(batteryId);
1435 if (it == infos.end()) {
Kim Low03ea0352020-11-06 12:45:07 -08001436 return std::nullopt;
1437 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001438 std::string buffer;
Kim Low03ea0352020-11-06 12:45:07 -08001439
1440 // Some devices report battery capacity as an integer through the "capacity" file
Chris Yee2b1e5c2021-03-10 22:45:12 -08001441 if (base::ReadFileToString(it->second.path / BATTERY_NODES.at(InputBatteryClass::CAPACITY),
1442 &buffer)) {
Chris Yed1936772021-02-22 10:30:40 -08001443 return std::stoi(base::Trim(buffer));
Kim Low03ea0352020-11-06 12:45:07 -08001444 }
1445
1446 // Other devices report capacity as an enum value POWER_SUPPLY_CAPACITY_LEVEL_XXX
1447 // These values are taken from kernel source code include/linux/power_supply.h
Chris Yee2b1e5c2021-03-10 22:45:12 -08001448 if (base::ReadFileToString(it->second.path /
1449 BATTERY_NODES.at(InputBatteryClass::CAPACITY_LEVEL),
1450 &buffer)) {
Chris Yed1936772021-02-22 10:30:40 -08001451 // Remove any white space such as trailing new line
Chris Yee2b1e5c2021-03-10 22:45:12 -08001452 const auto levelIt = BATTERY_LEVEL.find(base::Trim(buffer));
1453 if (levelIt != BATTERY_LEVEL.end()) {
1454 return levelIt->second;
Kim Low03ea0352020-11-06 12:45:07 -08001455 }
1456 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001457
Kim Low03ea0352020-11-06 12:45:07 -08001458 return std::nullopt;
1459}
1460
Chris Yee2b1e5c2021-03-10 22:45:12 -08001461std::optional<int32_t> EventHub::getBatteryStatus(int32_t deviceId, int32_t batteryId) const {
Kim Low03ea0352020-11-06 12:45:07 -08001462 std::scoped_lock _l(mLock);
Chris Yee2b1e5c2021-03-10 22:45:12 -08001463 const auto infos = getBatteryInfoLocked(deviceId);
1464 auto it = infos.find(batteryId);
1465 if (it == infos.end()) {
Kim Low03ea0352020-11-06 12:45:07 -08001466 return std::nullopt;
1467 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001468 std::string buffer;
Kim Low03ea0352020-11-06 12:45:07 -08001469
Chris Yee2b1e5c2021-03-10 22:45:12 -08001470 if (!base::ReadFileToString(it->second.path / BATTERY_NODES.at(InputBatteryClass::STATUS),
1471 &buffer)) {
Kim Low03ea0352020-11-06 12:45:07 -08001472 ALOGE("Failed to read sysfs battery info: %s", strerror(errno));
1473 return std::nullopt;
1474 }
1475
Chris Yed1936772021-02-22 10:30:40 -08001476 // Remove white space like trailing new line
Chris Yee2b1e5c2021-03-10 22:45:12 -08001477 const auto statusIt = BATTERY_STATUS.find(base::Trim(buffer));
1478 if (statusIt != BATTERY_STATUS.end()) {
1479 return statusIt->second;
Kim Low03ea0352020-11-06 12:45:07 -08001480 }
1481
1482 return std::nullopt;
1483}
1484
Michael Wrightd02c5b62014-02-10 15:10:22 -08001485size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
1486 ALOG_ASSERT(bufferSize >= 1);
1487
Chris Ye87143712020-11-10 05:05:58 +00001488 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001489
1490 struct input_event readBuffer[bufferSize];
1491
1492 RawEvent* event = buffer;
1493 size_t capacity = bufferSize;
1494 bool awoken = false;
1495 for (;;) {
1496 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
1497
1498 // Reopen input devices if needed.
1499 if (mNeedToReopenDevices) {
1500 mNeedToReopenDevices = false;
1501
1502 ALOGI("Reopening all input devices due to a configuration change.");
1503
1504 closeAllDevicesLocked();
1505 mNeedToScanDevices = true;
1506 break; // return to the caller before we actually rescan
1507 }
1508
1509 // Report any devices that had last been added/removed.
Chris Ye989bb932020-07-04 16:18:59 -07001510 for (auto it = mClosingDevices.begin(); it != mClosingDevices.end();) {
1511 std::unique_ptr<Device> device = std::move(*it);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001512 ALOGV("Reporting device closed: id=%d, name=%s\n", device->id, device->path.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001513 event->when = now;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001514 event->deviceId = (device->id == mBuiltInKeyboardId)
1515 ? ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID
1516 : device->id;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001517 event->type = DEVICE_REMOVED;
1518 event += 1;
Chris Ye989bb932020-07-04 16:18:59 -07001519 it = mClosingDevices.erase(it);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001520 mNeedToSendFinishedDeviceScan = true;
1521 if (--capacity == 0) {
1522 break;
1523 }
1524 }
1525
1526 if (mNeedToScanDevices) {
1527 mNeedToScanDevices = false;
1528 scanDevicesLocked();
1529 mNeedToSendFinishedDeviceScan = true;
1530 }
1531
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001532 while (!mOpeningDevices.empty()) {
1533 std::unique_ptr<Device> device = std::move(*mOpeningDevices.rbegin());
1534 mOpeningDevices.pop_back();
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001535 ALOGV("Reporting device opened: id=%d, name=%s\n", device->id, device->path.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001536 event->when = now;
1537 event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
1538 event->type = DEVICE_ADDED;
1539 event += 1;
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001540
1541 // Try to find a matching video device by comparing device names
1542 for (auto it = mUnattachedVideoDevices.begin(); it != mUnattachedVideoDevices.end();
1543 it++) {
1544 std::unique_ptr<TouchVideoDevice>& videoDevice = *it;
Chris Yed3fef462021-03-07 17:10:08 -08001545 if (tryAddVideoDeviceLocked(*device, videoDevice)) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001546 // videoDevice was transferred to 'device'
1547 it = mUnattachedVideoDevices.erase(it);
1548 break;
1549 }
1550 }
1551
1552 auto [dev_it, inserted] = mDevices.insert_or_assign(device->id, std::move(device));
1553 if (!inserted) {
Chris Ye989bb932020-07-04 16:18:59 -07001554 ALOGW("Device id %d exists, replaced.", device->id);
1555 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001556 mNeedToSendFinishedDeviceScan = true;
1557 if (--capacity == 0) {
1558 break;
1559 }
1560 }
1561
1562 if (mNeedToSendFinishedDeviceScan) {
1563 mNeedToSendFinishedDeviceScan = false;
1564 event->when = now;
1565 event->type = FINISHED_DEVICE_SCAN;
1566 event += 1;
1567 if (--capacity == 0) {
1568 break;
1569 }
1570 }
1571
1572 // Grab the next input event.
1573 bool deviceChanged = false;
1574 while (mPendingEventIndex < mPendingEventCount) {
1575 const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001576 if (eventItem.data.fd == mINotifyFd) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001577 if (eventItem.events & EPOLLIN) {
1578 mPendingINotify = true;
1579 } else {
1580 ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
1581 }
1582 continue;
1583 }
1584
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001585 if (eventItem.data.fd == mWakeReadPipeFd) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001586 if (eventItem.events & EPOLLIN) {
1587 ALOGV("awoken after wake()");
1588 awoken = true;
Siarhei Vishniakoub4d960d2019-10-03 15:38:44 -05001589 char wakeReadBuffer[16];
Michael Wrightd02c5b62014-02-10 15:10:22 -08001590 ssize_t nRead;
1591 do {
Siarhei Vishniakoub4d960d2019-10-03 15:38:44 -05001592 nRead = read(mWakeReadPipeFd, wakeReadBuffer, sizeof(wakeReadBuffer));
1593 } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(wakeReadBuffer));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001594 } else {
1595 ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001596 eventItem.events);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001597 }
1598 continue;
1599 }
1600
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001601 Device* device = getDeviceByFdLocked(eventItem.data.fd);
Chris Ye989bb932020-07-04 16:18:59 -07001602 if (device == nullptr) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001603 ALOGE("Received unexpected epoll event 0x%08x for unknown fd %d.", eventItem.events,
1604 eventItem.data.fd);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001605 ALOG_ASSERT(!DEBUG);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001606 continue;
1607 }
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001608 if (device->videoDevice && eventItem.data.fd == device->videoDevice->getFd()) {
1609 if (eventItem.events & EPOLLIN) {
1610 size_t numFrames = device->videoDevice->readAndQueueFrames();
1611 if (numFrames == 0) {
1612 ALOGE("Received epoll event for video device %s, but could not read frame",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001613 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001614 }
1615 } else if (eventItem.events & EPOLLHUP) {
1616 // TODO(b/121395353) - consider adding EPOLLRDHUP
1617 ALOGI("Removing video device %s due to epoll hang-up event.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001618 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001619 unregisterVideoDeviceFromEpollLocked(*device->videoDevice);
1620 device->videoDevice = nullptr;
1621 } else {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001622 ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events,
1623 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001624 ALOG_ASSERT(!DEBUG);
1625 }
1626 continue;
1627 }
1628 // This must be an input event
Michael Wrightd02c5b62014-02-10 15:10:22 -08001629 if (eventItem.events & EPOLLIN) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001630 int32_t readSize =
1631 read(device->fd, readBuffer, sizeof(struct input_event) * capacity);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001632 if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
1633 // Device was removed before INotify noticed.
Mark Salyzyn5aa26b22014-06-10 13:07:44 -07001634 ALOGW("could not get event, removed? (fd: %d size: %" PRId32
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001635 " bufferSize: %zu capacity: %zu errno: %d)\n",
1636 device->fd, readSize, bufferSize, capacity, errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001637 deviceChanged = true;
Chris Ye989bb932020-07-04 16:18:59 -07001638 closeDeviceLocked(*device);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001639 } else if (readSize < 0) {
1640 if (errno != EAGAIN && errno != EINTR) {
1641 ALOGW("could not get event (errno=%d)", errno);
1642 }
1643 } else if ((readSize % sizeof(struct input_event)) != 0) {
1644 ALOGE("could not get event (wrong size: %d)", readSize);
1645 } else {
1646 int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
1647
1648 size_t count = size_t(readSize) / sizeof(struct input_event);
1649 for (size_t i = 0; i < count; i++) {
1650 struct input_event& iev = readBuffer[i];
Siarhei Vishniakou592bac22018-11-08 19:42:38 -08001651 event->when = processEventTimestamp(iev);
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +00001652 event->readTime = systemTime(SYSTEM_TIME_MONOTONIC);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001653 event->deviceId = deviceId;
1654 event->type = iev.type;
1655 event->code = iev.code;
1656 event->value = iev.value;
1657 event += 1;
1658 capacity -= 1;
1659 }
1660 if (capacity == 0) {
1661 // The result buffer is full. Reset the pending event index
1662 // so we will try to read the device again on the next iteration.
1663 mPendingEventIndex -= 1;
1664 break;
1665 }
1666 }
1667 } else if (eventItem.events & EPOLLHUP) {
1668 ALOGI("Removing device %s due to epoll hang-up event.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001669 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001670 deviceChanged = true;
Chris Ye989bb932020-07-04 16:18:59 -07001671 closeDeviceLocked(*device);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001672 } else {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001673 ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events,
1674 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001675 }
1676 }
1677
1678 // readNotify() will modify the list of devices so this must be done after
1679 // processing all other events to ensure that we read all remaining events
1680 // before closing the devices.
1681 if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
1682 mPendingINotify = false;
1683 readNotifyLocked();
1684 deviceChanged = true;
1685 }
1686
1687 // Report added or removed devices immediately.
1688 if (deviceChanged) {
1689 continue;
1690 }
1691
1692 // Return now if we have collected any events or if we were explicitly awoken.
1693 if (event != buffer || awoken) {
1694 break;
1695 }
1696
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001697 // Poll for events.
1698 // When a device driver has pending (unread) events, it acquires
1699 // a kernel wake lock. Once the last pending event has been read, the device
1700 // driver will release the kernel wake lock, but the epoll will hold the wakelock,
1701 // since we are using EPOLLWAKEUP. The wakelock is released by the epoll when epoll_wait
1702 // is called again for the same fd that produced the event.
1703 // Thus the system can only sleep if there are no events pending or
1704 // currently being processed.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001705 //
1706 // The timeout is advisory only. If the device is asleep, it will not wake just to
1707 // service the timeout.
1708 mPendingEventIndex = 0;
1709
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001710 mLock.unlock(); // release lock before poll
Michael Wrightd02c5b62014-02-10 15:10:22 -08001711
1712 int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
1713
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001714 mLock.lock(); // reacquire lock after poll
Michael Wrightd02c5b62014-02-10 15:10:22 -08001715
1716 if (pollResult == 0) {
1717 // Timed out.
1718 mPendingEventCount = 0;
1719 break;
1720 }
1721
1722 if (pollResult < 0) {
1723 // An error occurred.
1724 mPendingEventCount = 0;
1725
1726 // Sleep after errors to avoid locking up the system.
1727 // Hopefully the error is transient.
1728 if (errno != EINTR) {
1729 ALOGW("poll failed (errno=%d)\n", errno);
1730 usleep(100000);
1731 }
1732 } else {
1733 // Some events occurred.
1734 mPendingEventCount = size_t(pollResult);
1735 }
1736 }
1737
1738 // All done, return the number of events we read.
1739 return event - buffer;
1740}
1741
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08001742std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00001743 std::scoped_lock _l(mLock);
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08001744
1745 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001746 if (device == nullptr || !device->videoDevice) {
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08001747 return {};
1748 }
1749 return device->videoDevice->consumeFrames();
1750}
1751
Michael Wrightd02c5b62014-02-10 15:10:22 -08001752void EventHub::wake() {
1753 ALOGV("wake() called");
1754
1755 ssize_t nWrite;
1756 do {
1757 nWrite = write(mWakeWritePipeFd, "W", 1);
1758 } while (nWrite == -1 && errno == EINTR);
1759
1760 if (nWrite != 1 && errno != EAGAIN) {
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08001761 ALOGW("Could not write wake signal: %s", strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001762 }
1763}
1764
1765void EventHub::scanDevicesLocked() {
Usama Arif78eb9752021-06-03 16:44:09 +01001766 status_t result;
1767 std::error_code errorCode;
1768
1769 if (std::filesystem::exists(DEVICE_INPUT_PATH, errorCode)) {
1770 result = scanDirLocked(DEVICE_INPUT_PATH);
1771 if (result < 0) {
1772 ALOGE("scan dir failed for %s", DEVICE_INPUT_PATH);
1773 }
1774 } else {
1775 if (errorCode) {
1776 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
1777 errorCode.message().c_str());
1778 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08001779 }
Philip Quinn39b81682019-01-09 22:20:39 -08001780 if (isV4lScanningEnabled()) {
Usama Arif78eb9752021-06-03 16:44:09 +01001781 result = scanVideoDirLocked(DEVICE_PATH);
Philip Quinn39b81682019-01-09 22:20:39 -08001782 if (result != OK) {
Usama Arif78eb9752021-06-03 16:44:09 +01001783 ALOGE("scan video dir failed for %s", DEVICE_PATH);
Philip Quinn39b81682019-01-09 22:20:39 -08001784 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001785 }
Chris Ye989bb932020-07-04 16:18:59 -07001786 if (mDevices.find(ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID) == mDevices.end()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001787 createVirtualKeyboardLocked();
1788 }
1789}
1790
1791// ----------------------------------------------------------------------------
1792
Michael Wrightd02c5b62014-02-10 15:10:22 -08001793static const int32_t GAMEPAD_KEYCODES[] = {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001794 AKEYCODE_BUTTON_A, AKEYCODE_BUTTON_B, AKEYCODE_BUTTON_C, //
1795 AKEYCODE_BUTTON_X, AKEYCODE_BUTTON_Y, AKEYCODE_BUTTON_Z, //
1796 AKEYCODE_BUTTON_L1, AKEYCODE_BUTTON_R1, //
1797 AKEYCODE_BUTTON_L2, AKEYCODE_BUTTON_R2, //
1798 AKEYCODE_BUTTON_THUMBL, AKEYCODE_BUTTON_THUMBR, //
1799 AKEYCODE_BUTTON_START, AKEYCODE_BUTTON_SELECT, AKEYCODE_BUTTON_MODE, //
Michael Wrightd02c5b62014-02-10 15:10:22 -08001800};
1801
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001802status_t EventHub::registerFdForEpoll(int fd) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001803 // TODO(b/121395353) - consider adding EPOLLRDHUP
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001804 struct epoll_event eventItem = {};
1805 eventItem.events = EPOLLIN | EPOLLWAKEUP;
1806 eventItem.data.fd = fd;
1807 if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
1808 ALOGE("Could not add fd to epoll instance: %s", strerror(errno));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07001809 return -errno;
1810 }
1811 return OK;
1812}
1813
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001814status_t EventHub::unregisterFdFromEpoll(int fd) {
1815 if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, nullptr)) {
1816 ALOGW("Could not remove fd from epoll instance: %s", strerror(errno));
1817 return -errno;
1818 }
1819 return OK;
1820}
1821
Chris Ye989bb932020-07-04 16:18:59 -07001822status_t EventHub::registerDeviceForEpollLocked(Device& device) {
1823 status_t result = registerFdForEpoll(device.fd);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001824 if (result != OK) {
Chris Ye989bb932020-07-04 16:18:59 -07001825 ALOGE("Could not add input device fd to epoll for device %" PRId32, device.id);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001826 return result;
1827 }
Chris Ye989bb932020-07-04 16:18:59 -07001828 if (device.videoDevice) {
1829 registerVideoDeviceForEpollLocked(*device.videoDevice);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001830 }
1831 return result;
1832}
1833
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001834void EventHub::registerVideoDeviceForEpollLocked(const TouchVideoDevice& videoDevice) {
1835 status_t result = registerFdForEpoll(videoDevice.getFd());
1836 if (result != OK) {
1837 ALOGE("Could not add video device %s to epoll", videoDevice.getName().c_str());
1838 }
1839}
1840
Chris Ye989bb932020-07-04 16:18:59 -07001841status_t EventHub::unregisterDeviceFromEpollLocked(Device& device) {
1842 if (device.hasValidFd()) {
1843 status_t result = unregisterFdFromEpoll(device.fd);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001844 if (result != OK) {
Chris Ye989bb932020-07-04 16:18:59 -07001845 ALOGW("Could not remove input device fd from epoll for device %" PRId32, device.id);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08001846 return result;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07001847 }
1848 }
Chris Ye989bb932020-07-04 16:18:59 -07001849 if (device.videoDevice) {
1850 unregisterVideoDeviceFromEpollLocked(*device.videoDevice);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001851 }
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07001852 return OK;
1853}
1854
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001855void EventHub::unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& videoDevice) {
1856 if (videoDevice.hasValidFd()) {
1857 status_t result = unregisterFdFromEpoll(videoDevice.getFd());
1858 if (result != OK) {
1859 ALOGW("Could not remove video device fd from epoll for device: %s",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001860 videoDevice.getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001861 }
1862 }
1863}
1864
Chris Yed3fef462021-03-07 17:10:08 -08001865void EventHub::reportDeviceAddedForStatisticsLocked(const InputDeviceIdentifier& identifier,
1866 Flags<InputDeviceClass> classes) {
Chris Ye657c2f02021-05-25 16:24:37 -07001867 SHA256_CTX ctx;
1868 SHA256_Init(&ctx);
1869 SHA256_Update(&ctx, reinterpret_cast<const uint8_t*>(identifier.uniqueId.c_str()),
1870 identifier.uniqueId.size());
1871 std::array<uint8_t, SHA256_DIGEST_LENGTH> digest;
1872 SHA256_Final(digest.data(), &ctx);
1873
1874 std::string obfuscatedId;
1875 for (size_t i = 0; i < OBFUSCATED_LENGTH; i++) {
1876 obfuscatedId += StringPrintf("%02x", digest[i]);
1877 }
1878
Chris Yed3fef462021-03-07 17:10:08 -08001879 android::util::stats_write(android::util::INPUTDEVICE_REGISTERED, identifier.name.c_str(),
1880 identifier.vendor, identifier.product, identifier.version,
Chris Ye657c2f02021-05-25 16:24:37 -07001881 identifier.bus, obfuscatedId.c_str(), classes.get());
Chris Yed3fef462021-03-07 17:10:08 -08001882}
1883
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00001884void EventHub::openDeviceLocked(const std::string& devicePath) {
1885 // If an input device happens to register around the time when EventHub's constructor runs, it
1886 // is possible that the same input event node (for example, /dev/input/event3) will be noticed
1887 // in both 'inotify' callback and also in the 'scanDirLocked' pass. To prevent duplicate devices
1888 // from getting registered, ensure that this path is not already covered by an existing device.
1889 for (const auto& [deviceId, device] : mDevices) {
1890 if (device->path == devicePath) {
1891 return; // device was already registered
1892 }
1893 }
1894
Michael Wrightd02c5b62014-02-10 15:10:22 -08001895 char buffer[80];
1896
Chris Ye8594e192020-07-14 10:34:06 -07001897 ALOGV("Opening device: %s", devicePath.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001898
Chris Ye8594e192020-07-14 10:34:06 -07001899 int fd = open(devicePath.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001900 if (fd < 0) {
Chris Ye8594e192020-07-14 10:34:06 -07001901 ALOGE("could not open %s, %s\n", devicePath.c_str(), strerror(errno));
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00001902 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001903 }
1904
1905 InputDeviceIdentifier identifier;
1906
1907 // Get device name.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001908 if (ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {
Chris Ye8594e192020-07-14 10:34:06 -07001909 ALOGE("Could not get device name for %s: %s", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001910 } else {
1911 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001912 identifier.name = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001913 }
1914
1915 // Check to see if the device is on our excluded list
1916 for (size_t i = 0; i < mExcludedDevices.size(); i++) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001917 const std::string& item = mExcludedDevices[i];
Michael Wrightd02c5b62014-02-10 15:10:22 -08001918 if (identifier.name == item) {
Chris Ye8594e192020-07-14 10:34:06 -07001919 ALOGI("ignoring event id %s driver %s\n", devicePath.c_str(), item.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001920 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00001921 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001922 }
1923 }
1924
1925 // Get device driver version.
1926 int driverVersion;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001927 if (ioctl(fd, EVIOCGVERSION, &driverVersion)) {
Chris Ye8594e192020-07-14 10:34:06 -07001928 ALOGE("could not get driver version for %s, %s\n", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001929 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00001930 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001931 }
1932
1933 // Get device identifier.
1934 struct input_id inputId;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001935 if (ioctl(fd, EVIOCGID, &inputId)) {
Chris Ye8594e192020-07-14 10:34:06 -07001936 ALOGE("could not get device input id for %s, %s\n", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001937 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00001938 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001939 }
1940 identifier.bus = inputId.bustype;
1941 identifier.product = inputId.product;
1942 identifier.vendor = inputId.vendor;
1943 identifier.version = inputId.version;
1944
1945 // Get device physical location.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001946 if (ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) {
1947 // fprintf(stderr, "could not get location for %s, %s\n", devicePath, strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001948 } else {
1949 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001950 identifier.location = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001951 }
1952
1953 // Get device unique id.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001954 if (ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) {
1955 // fprintf(stderr, "could not get idstring for %s, %s\n", devicePath, strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001956 } else {
1957 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001958 identifier.uniqueId = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001959 }
1960
1961 // Fill in the descriptor.
1962 assignDescriptorLocked(identifier);
1963
Michael Wrightd02c5b62014-02-10 15:10:22 -08001964 // Allocate device. (The device object takes ownership of the fd at this point.)
1965 int32_t deviceId = mNextDeviceId++;
Chris Ye989bb932020-07-04 16:18:59 -07001966 std::unique_ptr<Device> device = std::make_unique<Device>(fd, deviceId, devicePath, identifier);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001967
Chris Ye8594e192020-07-14 10:34:06 -07001968 ALOGV("add device %d: %s\n", deviceId, devicePath.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001969 ALOGV(" bus: %04x\n"
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001970 " vendor %04x\n"
1971 " product %04x\n"
1972 " version %04x\n",
1973 identifier.bus, identifier.vendor, identifier.product, identifier.version);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001974 ALOGV(" name: \"%s\"\n", identifier.name.c_str());
1975 ALOGV(" location: \"%s\"\n", identifier.location.c_str());
1976 ALOGV(" unique id: \"%s\"\n", identifier.uniqueId.c_str());
1977 ALOGV(" descriptor: \"%s\"\n", identifier.descriptor.c_str());
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001978 ALOGV(" driver: v%d.%d.%d\n", driverVersion >> 16, (driverVersion >> 8) & 0xff,
1979 driverVersion & 0xff);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001980
1981 // Load the configuration file for the device.
Chris Ye989bb932020-07-04 16:18:59 -07001982 device->loadConfigurationLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001983
Chris Yee2b1e5c2021-03-10 22:45:12 -08001984 bool hasBattery = false;
1985 bool hasLights = false;
1986 // Check the sysfs root path
1987 std::optional<std::filesystem::path> sysfsRootPath = getSysfsRootPath(devicePath.c_str());
1988 if (sysfsRootPath.has_value()) {
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001989 std::shared_ptr<AssociatedDevice> associatedDevice;
1990 for (const auto& [id, dev] : mDevices) {
1991 if (device->identifier.descriptor == dev->identifier.descriptor &&
1992 !dev->associatedDevice) {
1993 associatedDevice = dev->associatedDevice;
1994 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001995 }
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001996 if (!associatedDevice) {
1997 associatedDevice = std::make_shared<AssociatedDevice>(sysfsRootPath.value());
1998 }
1999 hasBattery = associatedDevice->configureBatteryLocked();
2000 hasLights = associatedDevice->configureLightsLocked();
Chris Yee2b1e5c2021-03-10 22:45:12 -08002001
Chris Ye1dd2e5c2021-04-04 23:12:41 -07002002 device->associatedDevice = associatedDevice;
Chris Yee2b1e5c2021-03-10 22:45:12 -08002003 }
Chris Ye3fdbfef2021-01-06 18:45:18 -08002004
Michael Wrightd02c5b62014-02-10 15:10:22 -08002005 // Figure out the kinds of events the device reports.
Chris Ye66fbac32020-07-06 20:36:43 -07002006 device->readDeviceBitMask(EVIOCGBIT(EV_KEY, 0), device->keyBitmask);
2007 device->readDeviceBitMask(EVIOCGBIT(EV_ABS, 0), device->absBitmask);
2008 device->readDeviceBitMask(EVIOCGBIT(EV_REL, 0), device->relBitmask);
2009 device->readDeviceBitMask(EVIOCGBIT(EV_SW, 0), device->swBitmask);
2010 device->readDeviceBitMask(EVIOCGBIT(EV_LED, 0), device->ledBitmask);
2011 device->readDeviceBitMask(EVIOCGBIT(EV_FF, 0), device->ffBitmask);
Chris Yef59a2f42020-10-16 12:55:26 -07002012 device->readDeviceBitMask(EVIOCGBIT(EV_MSC, 0), device->mscBitmask);
Chris Ye66fbac32020-07-06 20:36:43 -07002013 device->readDeviceBitMask(EVIOCGPROP(0), device->propBitmask);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002014
2015 // See if this is a keyboard. Ignore everything in the button range except for
2016 // joystick and gamepad buttons which are handled like keyboards for the most part.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002017 bool haveKeyboardKeys =
Chris Ye66fbac32020-07-06 20:36:43 -07002018 device->keyBitmask.any(0, BTN_MISC) || device->keyBitmask.any(BTN_WHEEL, KEY_MAX + 1);
2019 bool haveGamepadButtons = device->keyBitmask.any(BTN_MISC, BTN_MOUSE) ||
2020 device->keyBitmask.any(BTN_JOYSTICK, BTN_DIGI);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002021 if (haveKeyboardKeys || haveGamepadButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002022 device->classes |= InputDeviceClass::KEYBOARD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002023 }
2024
2025 // See if this is a cursor device such as a trackball or mouse.
Chris Ye66fbac32020-07-06 20:36:43 -07002026 if (device->keyBitmask.test(BTN_MOUSE) && device->relBitmask.test(REL_X) &&
2027 device->relBitmask.test(REL_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002028 device->classes |= InputDeviceClass::CURSOR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002029 }
2030
Prashant Malani1941ff52015-08-11 18:29:28 -07002031 // See if this is a rotary encoder type device.
2032 String8 deviceType = String8();
2033 if (device->configuration &&
2034 device->configuration->tryGetProperty(String8("device.type"), deviceType)) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002035 if (!deviceType.compare(String8("rotaryEncoder"))) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002036 device->classes |= InputDeviceClass::ROTARY_ENCODER;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002037 }
Prashant Malani1941ff52015-08-11 18:29:28 -07002038 }
2039
Michael Wrightd02c5b62014-02-10 15:10:22 -08002040 // See if this is a touch pad.
2041 // Is this a new modern multi-touch driver?
Chris Ye66fbac32020-07-06 20:36:43 -07002042 if (device->absBitmask.test(ABS_MT_POSITION_X) && device->absBitmask.test(ABS_MT_POSITION_Y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002043 // Some joysticks such as the PS3 controller report axes that conflict
2044 // with the ABS_MT range. Try to confirm that the device really is
2045 // a touch screen.
Chris Ye66fbac32020-07-06 20:36:43 -07002046 if (device->keyBitmask.test(BTN_TOUCH) || !haveGamepadButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002047 device->classes |= (InputDeviceClass::TOUCH | InputDeviceClass::TOUCH_MT);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002048 }
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002049 // Is this an old style single-touch driver?
Chris Ye66fbac32020-07-06 20:36:43 -07002050 } else if (device->keyBitmask.test(BTN_TOUCH) && device->absBitmask.test(ABS_X) &&
2051 device->absBitmask.test(ABS_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002052 device->classes |= InputDeviceClass::TOUCH;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002053 // Is this a BT stylus?
Chris Ye66fbac32020-07-06 20:36:43 -07002054 } else if ((device->absBitmask.test(ABS_PRESSURE) || device->keyBitmask.test(BTN_TOUCH)) &&
2055 !device->absBitmask.test(ABS_X) && !device->absBitmask.test(ABS_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002056 device->classes |= InputDeviceClass::EXTERNAL_STYLUS;
Michael Wright842500e2015-03-13 17:32:02 -07002057 // Keyboard will try to claim some of the buttons but we really want to reserve those so we
2058 // can fuse it with the touch screen data, so just take them back. Note this means an
2059 // external stylus cannot also be a keyboard device.
Chris Ye1b0c7342020-07-28 21:57:03 -07002060 device->classes &= ~InputDeviceClass::KEYBOARD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002061 }
2062
2063 // See if this device is a joystick.
2064 // Assumes that joysticks always have gamepad buttons in order to distinguish them
2065 // from other devices such as accelerometers that also have absolute axes.
2066 if (haveGamepadButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002067 auto assumedClasses = device->classes | InputDeviceClass::JOYSTICK;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002068 for (int i = 0; i <= ABS_MAX; i++) {
Chris Ye66fbac32020-07-06 20:36:43 -07002069 if (device->absBitmask.test(i) &&
Chris Ye1b0c7342020-07-28 21:57:03 -07002070 (getAbsAxisUsage(i, assumedClasses).test(InputDeviceClass::JOYSTICK))) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002071 device->classes = assumedClasses;
2072 break;
2073 }
2074 }
2075 }
2076
Chris Yef59a2f42020-10-16 12:55:26 -07002077 // Check whether this device is an accelerometer.
2078 if (device->propBitmask.test(INPUT_PROP_ACCELEROMETER)) {
2079 device->classes |= InputDeviceClass::SENSOR;
2080 }
2081
Michael Wrightd02c5b62014-02-10 15:10:22 -08002082 // Check whether this device has switches.
2083 for (int i = 0; i <= SW_MAX; i++) {
Chris Ye66fbac32020-07-06 20:36:43 -07002084 if (device->swBitmask.test(i)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002085 device->classes |= InputDeviceClass::SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002086 break;
2087 }
2088 }
2089
2090 // Check whether this device supports the vibrator.
Chris Ye66fbac32020-07-06 20:36:43 -07002091 if (device->ffBitmask.test(FF_RUMBLE)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002092 device->classes |= InputDeviceClass::VIBRATOR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002093 }
2094
2095 // Configure virtual keys.
Chris Ye1b0c7342020-07-28 21:57:03 -07002096 if ((device->classes.test(InputDeviceClass::TOUCH))) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002097 // Load the virtual keys for the touch screen, if any.
2098 // We do this now so that we can make sure to load the keymap if necessary.
Chris Ye989bb932020-07-04 16:18:59 -07002099 bool success = device->loadVirtualKeyMapLocked();
Siarhei Vishniakou3e78dec2019-02-20 16:21:46 -06002100 if (success) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002101 device->classes |= InputDeviceClass::KEYBOARD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002102 }
2103 }
2104
2105 // Load the key map.
Chris Yef59a2f42020-10-16 12:55:26 -07002106 // We need to do this for joysticks too because the key layout may specify axes, and for
2107 // sensor as well because the key layout may specify the axes to sensor data mapping.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002108 status_t keyMapStatus = NAME_NOT_FOUND;
Chris Yef59a2f42020-10-16 12:55:26 -07002109 if (device->classes.any(InputDeviceClass::KEYBOARD | InputDeviceClass::JOYSTICK |
2110 InputDeviceClass::SENSOR)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002111 // Load the keymap for the device.
Chris Ye989bb932020-07-04 16:18:59 -07002112 keyMapStatus = device->loadKeyMapLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002113 }
2114
2115 // Configure the keyboard, gamepad or virtual keyboard.
Chris Ye1b0c7342020-07-28 21:57:03 -07002116 if (device->classes.test(InputDeviceClass::KEYBOARD)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002117 // Register the keyboard as a built-in keyboard if it is eligible.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002118 if (!keyMapStatus && mBuiltInKeyboardId == NO_BUILT_IN_KEYBOARD &&
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002119 isEligibleBuiltInKeyboard(device->identifier, device->configuration.get(),
2120 &device->keyMap)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002121 mBuiltInKeyboardId = device->id;
2122 }
2123
2124 // 'Q' key support = cheap test of whether this is an alpha-capable kbd
Chris Ye989bb932020-07-04 16:18:59 -07002125 if (device->hasKeycodeLocked(AKEYCODE_Q)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002126 device->classes |= InputDeviceClass::ALPHAKEY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002127 }
2128
2129 // See if this device has a DPAD.
Chris Ye989bb932020-07-04 16:18:59 -07002130 if (device->hasKeycodeLocked(AKEYCODE_DPAD_UP) &&
2131 device->hasKeycodeLocked(AKEYCODE_DPAD_DOWN) &&
2132 device->hasKeycodeLocked(AKEYCODE_DPAD_LEFT) &&
2133 device->hasKeycodeLocked(AKEYCODE_DPAD_RIGHT) &&
2134 device->hasKeycodeLocked(AKEYCODE_DPAD_CENTER)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002135 device->classes |= InputDeviceClass::DPAD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002136 }
2137
2138 // See if this device has a gamepad.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002139 for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES) / sizeof(GAMEPAD_KEYCODES[0]); i++) {
Chris Ye989bb932020-07-04 16:18:59 -07002140 if (device->hasKeycodeLocked(GAMEPAD_KEYCODES[i])) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002141 device->classes |= InputDeviceClass::GAMEPAD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002142 break;
2143 }
2144 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002145 }
2146
2147 // If the device isn't recognized as something we handle, don't monitor it.
Chris Ye1b0c7342020-07-28 21:57:03 -07002148 if (device->classes == Flags<InputDeviceClass>(0)) {
Chris Ye8594e192020-07-14 10:34:06 -07002149 ALOGV("Dropping device: id=%d, path='%s', name='%s'", deviceId, devicePath.c_str(),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002150 device->identifier.name.c_str());
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002151 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002152 }
2153
Chris Ye3fdbfef2021-01-06 18:45:18 -08002154 // Classify InputDeviceClass::BATTERY.
2155 if (hasBattery) {
2156 device->classes |= InputDeviceClass::BATTERY;
2157 }
Kim Low03ea0352020-11-06 12:45:07 -08002158
Chris Ye3fdbfef2021-01-06 18:45:18 -08002159 // Classify InputDeviceClass::LIGHT.
2160 if (hasLights) {
2161 device->classes |= InputDeviceClass::LIGHT;
Kim Low03ea0352020-11-06 12:45:07 -08002162 }
2163
Tim Kilbourn063ff532015-04-08 10:26:18 -07002164 // Determine whether the device has a mic.
Chris Ye989bb932020-07-04 16:18:59 -07002165 if (device->deviceHasMicLocked()) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002166 device->classes |= InputDeviceClass::MIC;
Tim Kilbourn063ff532015-04-08 10:26:18 -07002167 }
2168
Michael Wrightd02c5b62014-02-10 15:10:22 -08002169 // Determine whether the device is external or internal.
Chris Ye989bb932020-07-04 16:18:59 -07002170 if (device->isExternalDeviceLocked()) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002171 device->classes |= InputDeviceClass::EXTERNAL;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002172 }
2173
Chris Ye1b0c7342020-07-28 21:57:03 -07002174 if (device->classes.any(InputDeviceClass::JOYSTICK | InputDeviceClass::DPAD) &&
2175 device->classes.test(InputDeviceClass::GAMEPAD)) {
Chris Ye989bb932020-07-04 16:18:59 -07002176 device->controllerNumber = getNextControllerNumberLocked(device->identifier.name);
2177 device->setLedForControllerLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002178 }
2179
Chris Ye989bb932020-07-04 16:18:59 -07002180 if (registerDeviceForEpollLocked(*device) != OK) {
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002181 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002182 }
2183
Chris Ye989bb932020-07-04 16:18:59 -07002184 device->configureFd();
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002185
Chris Ye1b0c7342020-07-28 21:57:03 -07002186 ALOGI("New device: id=%d, fd=%d, path='%s', name='%s', classes=%s, "
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002187 "configuration='%s', keyLayout='%s', keyCharacterMap='%s', builtinKeyboard=%s, ",
Chris Ye1b0c7342020-07-28 21:57:03 -07002188 deviceId, fd, devicePath.c_str(), device->identifier.name.c_str(),
2189 device->classes.string().c_str(), device->configurationFile.c_str(),
2190 device->keyMap.keyLayoutFile.c_str(), device->keyMap.keyCharacterMapFile.c_str(),
2191 toString(mBuiltInKeyboardId == deviceId));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002192
Chris Ye989bb932020-07-04 16:18:59 -07002193 addDeviceLocked(std::move(device));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002194}
2195
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002196void EventHub::openVideoDeviceLocked(const std::string& devicePath) {
2197 std::unique_ptr<TouchVideoDevice> videoDevice = TouchVideoDevice::create(devicePath);
2198 if (!videoDevice) {
2199 ALOGE("Could not create touch video device for %s. Ignoring", devicePath.c_str());
2200 return;
2201 }
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002202 // Transfer ownership of this video device to a matching input device
Chris Ye989bb932020-07-04 16:18:59 -07002203 for (const auto& [id, device] : mDevices) {
Chris Yed3fef462021-03-07 17:10:08 -08002204 if (tryAddVideoDeviceLocked(*device, videoDevice)) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05002205 return; // 'device' now owns 'videoDevice'
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002206 }
2207 }
2208
2209 // Couldn't find a matching input device, so just add it to a temporary holding queue.
2210 // A matching input device may appear later.
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002211 ALOGI("Adding video device %s to list of unattached video devices",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002212 videoDevice->getName().c_str());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002213 mUnattachedVideoDevices.push_back(std::move(videoDevice));
2214}
2215
Chris Yed3fef462021-03-07 17:10:08 -08002216bool EventHub::tryAddVideoDeviceLocked(EventHub::Device& device,
2217 std::unique_ptr<TouchVideoDevice>& videoDevice) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05002218 if (videoDevice->getName() != device.identifier.name) {
2219 return false;
2220 }
2221 device.videoDevice = std::move(videoDevice);
2222 if (device.enabled) {
2223 registerVideoDeviceForEpollLocked(*device.videoDevice);
2224 }
2225 return true;
2226}
2227
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002228bool EventHub::isDeviceEnabled(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002229 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002230 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002231 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002232 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2233 return false;
2234 }
2235 return device->enabled;
2236}
Michael Wrightd02c5b62014-02-10 15:10:22 -08002237
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002238status_t EventHub::enableDevice(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002239 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002240 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002241 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002242 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2243 return BAD_VALUE;
2244 }
2245 if (device->enabled) {
2246 ALOGW("Duplicate call to %s, input device %" PRId32 " already enabled", __func__, deviceId);
2247 return OK;
2248 }
2249 status_t result = device->enable();
2250 if (result != OK) {
2251 ALOGE("Failed to enable device %" PRId32, deviceId);
2252 return result;
2253 }
2254
Chris Ye989bb932020-07-04 16:18:59 -07002255 device->configureFd();
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002256
Chris Ye989bb932020-07-04 16:18:59 -07002257 return registerDeviceForEpollLocked(*device);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002258}
2259
2260status_t EventHub::disableDevice(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002261 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002262 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002263 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002264 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2265 return BAD_VALUE;
2266 }
2267 if (!device->enabled) {
2268 ALOGW("Duplicate call to %s, input device already disabled", __func__);
2269 return OK;
2270 }
Chris Ye989bb932020-07-04 16:18:59 -07002271 unregisterDeviceFromEpollLocked(*device);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002272 return device->disable();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002273}
2274
2275void EventHub::createVirtualKeyboardLocked() {
2276 InputDeviceIdentifier identifier;
2277 identifier.name = "Virtual";
2278 identifier.uniqueId = "<virtual>";
2279 assignDescriptorLocked(identifier);
2280
Chris Ye989bb932020-07-04 16:18:59 -07002281 std::unique_ptr<Device> device =
2282 std::make_unique<Device>(-1, ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID, "<virtual>",
2283 identifier);
Chris Ye1b0c7342020-07-28 21:57:03 -07002284 device->classes = InputDeviceClass::KEYBOARD | InputDeviceClass::ALPHAKEY |
2285 InputDeviceClass::DPAD | InputDeviceClass::VIRTUAL;
Chris Ye989bb932020-07-04 16:18:59 -07002286 device->loadKeyMapLocked();
2287 addDeviceLocked(std::move(device));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002288}
2289
Chris Ye989bb932020-07-04 16:18:59 -07002290void EventHub::addDeviceLocked(std::unique_ptr<Device> device) {
Chris Yed3fef462021-03-07 17:10:08 -08002291 reportDeviceAddedForStatisticsLocked(device->identifier, device->classes);
Chris Ye989bb932020-07-04 16:18:59 -07002292 mOpeningDevices.push_back(std::move(device));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002293}
2294
Chris Ye989bb932020-07-04 16:18:59 -07002295int32_t EventHub::getNextControllerNumberLocked(const std::string& name) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002296 if (mControllerNumbers.isFull()) {
2297 ALOGI("Maximum number of controllers reached, assigning controller number 0 to device %s",
Chris Ye989bb932020-07-04 16:18:59 -07002298 name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002299 return 0;
2300 }
2301 // Since the controller number 0 is reserved for non-controllers, translate all numbers up by
2302 // one
2303 return static_cast<int32_t>(mControllerNumbers.markFirstUnmarkedBit() + 1);
2304}
2305
Chris Ye989bb932020-07-04 16:18:59 -07002306void EventHub::releaseControllerNumberLocked(int32_t num) {
2307 if (num > 0) {
2308 mControllerNumbers.clearBit(static_cast<uint32_t>(num - 1));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002309 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002310}
2311
Chris Ye8594e192020-07-14 10:34:06 -07002312void EventHub::closeDeviceByPathLocked(const std::string& devicePath) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002313 Device* device = getDeviceByPathLocked(devicePath);
Chris Ye989bb932020-07-04 16:18:59 -07002314 if (device != nullptr) {
2315 closeDeviceLocked(*device);
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002316 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002317 }
Chris Ye8594e192020-07-14 10:34:06 -07002318 ALOGV("Remove device: %s not found, device may already have been removed.", devicePath.c_str());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002319}
2320
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002321/**
2322 * Find the video device by filename, and close it.
2323 * The video device is closed by path during an inotify event, where we don't have the
2324 * additional context about the video device fd, or the associated input device.
2325 */
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002326void EventHub::closeVideoDeviceByPathLocked(const std::string& devicePath) {
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002327 // A video device may be owned by an existing input device, or it may be stored in
2328 // the mUnattachedVideoDevices queue. Check both locations.
Chris Ye989bb932020-07-04 16:18:59 -07002329 for (const auto& [id, device] : mDevices) {
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002330 if (device->videoDevice && device->videoDevice->getPath() == devicePath) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002331 unregisterVideoDeviceFromEpollLocked(*device->videoDevice);
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002332 device->videoDevice = nullptr;
2333 return;
2334 }
2335 }
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002336 mUnattachedVideoDevices
2337 .erase(std::remove_if(mUnattachedVideoDevices.begin(), mUnattachedVideoDevices.end(),
2338 [&devicePath](
2339 const std::unique_ptr<TouchVideoDevice>& videoDevice) {
2340 return videoDevice->getPath() == devicePath;
2341 }),
2342 mUnattachedVideoDevices.end());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002343}
2344
2345void EventHub::closeAllDevicesLocked() {
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002346 mUnattachedVideoDevices.clear();
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002347 while (!mDevices.empty()) {
2348 closeDeviceLocked(*(mDevices.begin()->second));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002349 }
2350}
2351
Chris Ye989bb932020-07-04 16:18:59 -07002352void EventHub::closeDeviceLocked(Device& device) {
2353 ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=%s", device.path.c_str(),
2354 device.identifier.name.c_str(), device.id, device.fd, device.classes.string().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002355
Chris Ye989bb932020-07-04 16:18:59 -07002356 if (device.id == mBuiltInKeyboardId) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002357 ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this",
Chris Ye989bb932020-07-04 16:18:59 -07002358 device.path.c_str(), mBuiltInKeyboardId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002359 mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD;
2360 }
2361
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002362 unregisterDeviceFromEpollLocked(device);
Chris Ye989bb932020-07-04 16:18:59 -07002363 if (device.videoDevice) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002364 // This must be done after the video device is removed from epoll
Chris Ye989bb932020-07-04 16:18:59 -07002365 mUnattachedVideoDevices.push_back(std::move(device.videoDevice));
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002366 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002367
Chris Ye989bb932020-07-04 16:18:59 -07002368 releaseControllerNumberLocked(device.controllerNumber);
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002369 device.controllerNumber = 0;
Chris Ye989bb932020-07-04 16:18:59 -07002370 device.close();
Chris Ye989bb932020-07-04 16:18:59 -07002371 mClosingDevices.push_back(std::move(mDevices[device.id]));
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002372
Chris Ye989bb932020-07-04 16:18:59 -07002373 mDevices.erase(device.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002374}
2375
2376status_t EventHub::readNotifyLocked() {
2377 int res;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002378 char event_buf[512];
2379 int event_size;
2380 int event_pos = 0;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002381 struct inotify_event* event;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002382
2383 ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd);
2384 res = read(mINotifyFd, event_buf, sizeof(event_buf));
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002385 if (res < (int)sizeof(*event)) {
2386 if (errno == EINTR) return 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002387 ALOGW("could not get event, %s\n", strerror(errno));
2388 return -1;
2389 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002390
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002391 while (res >= (int)sizeof(*event)) {
2392 event = (struct inotify_event*)(event_buf + event_pos);
2393 if (event->len) {
Usama Arif78eb9752021-06-03 16:44:09 +01002394 if (event->wd == mDeviceInputWd) {
2395 std::string filename = std::string(DEVICE_INPUT_PATH) + "/" + event->name;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002396 if (event->mask & IN_CREATE) {
Chris Ye8594e192020-07-14 10:34:06 -07002397 openDeviceLocked(filename);
Siarhei Vishniakou951f3622018-12-12 19:45:42 -08002398 } else {
2399 ALOGI("Removing device '%s' due to inotify event\n", filename.c_str());
Chris Ye8594e192020-07-14 10:34:06 -07002400 closeDeviceByPathLocked(filename);
Siarhei Vishniakou951f3622018-12-12 19:45:42 -08002401 }
Usama Arif78eb9752021-06-03 16:44:09 +01002402 } else if (event->wd == mDeviceWd) {
Siarhei Vishniakou951f3622018-12-12 19:45:42 -08002403 if (isV4lTouchNode(event->name)) {
Usama Arif78eb9752021-06-03 16:44:09 +01002404 std::string filename = std::string(DEVICE_PATH) + "/" + event->name;
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002405 if (event->mask & IN_CREATE) {
2406 openVideoDeviceLocked(filename);
2407 } else {
2408 ALOGI("Removing video device '%s' due to inotify event", filename.c_str());
2409 closeVideoDeviceByPathLocked(filename);
2410 }
Usama Arif78eb9752021-06-03 16:44:09 +01002411 } else if (strcmp(event->name, "input") == 0 && event->mask & IN_CREATE) {
2412 addDeviceInputInotify();
Siarhei Vishniakou951f3622018-12-12 19:45:42 -08002413 }
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002414 } else {
Siarhei Vishniakou951f3622018-12-12 19:45:42 -08002415 LOG_ALWAYS_FATAL("Unexpected inotify event, wd = %i", event->wd);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002416 }
2417 }
2418 event_size = sizeof(*event) + event->len;
2419 res -= event_size;
2420 event_pos += event_size;
2421 }
2422 return 0;
2423}
2424
Chris Ye8594e192020-07-14 10:34:06 -07002425status_t EventHub::scanDirLocked(const std::string& dirname) {
2426 for (const auto& entry : std::filesystem::directory_iterator(dirname)) {
2427 openDeviceLocked(entry.path());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002428 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002429 return 0;
2430}
2431
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002432/**
2433 * Look for all dirname/v4l-touch* devices, and open them.
2434 */
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002435status_t EventHub::scanVideoDirLocked(const std::string& dirname) {
Chris Ye8594e192020-07-14 10:34:06 -07002436 for (const auto& entry : std::filesystem::directory_iterator(dirname)) {
2437 if (isV4lTouchNode(entry.path())) {
2438 ALOGI("Found touch video device %s", entry.path().c_str());
2439 openVideoDeviceLocked(entry.path());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002440 }
2441 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002442 return OK;
2443}
2444
Michael Wrightd02c5b62014-02-10 15:10:22 -08002445void EventHub::requestReopenDevices() {
2446 ALOGV("requestReopenDevices() called");
2447
Chris Ye87143712020-11-10 05:05:58 +00002448 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002449 mNeedToReopenDevices = true;
2450}
2451
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002452void EventHub::dump(std::string& dump) {
2453 dump += "Event Hub State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002454
2455 { // acquire lock
Chris Ye87143712020-11-10 05:05:58 +00002456 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002457
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002458 dump += StringPrintf(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002459
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002460 dump += INDENT "Devices:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002461
Chris Ye989bb932020-07-04 16:18:59 -07002462 for (const auto& [id, device] : mDevices) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002463 if (mBuiltInKeyboardId == device->id) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002464 dump += StringPrintf(INDENT2 "%d: %s (aka device 0 - built-in keyboard)\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002465 device->id, device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002466 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002467 dump += StringPrintf(INDENT2 "%d: %s\n", device->id,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002468 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002469 }
Chris Ye1b0c7342020-07-28 21:57:03 -07002470 dump += StringPrintf(INDENT3 "Classes: %s\n", device->classes.string().c_str());
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002471 dump += StringPrintf(INDENT3 "Path: %s\n", device->path.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002472 dump += StringPrintf(INDENT3 "Enabled: %s\n", toString(device->enabled));
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002473 dump += StringPrintf(INDENT3 "Descriptor: %s\n", device->identifier.descriptor.c_str());
2474 dump += StringPrintf(INDENT3 "Location: %s\n", device->identifier.location.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002475 dump += StringPrintf(INDENT3 "ControllerNumber: %d\n", device->controllerNumber);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002476 dump += StringPrintf(INDENT3 "UniqueId: %s\n", device->identifier.uniqueId.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002477 dump += StringPrintf(INDENT3 "Identifier: bus=0x%04x, vendor=0x%04x, "
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002478 "product=0x%04x, version=0x%04x\n",
2479 device->identifier.bus, device->identifier.vendor,
2480 device->identifier.product, device->identifier.version);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002481 dump += StringPrintf(INDENT3 "KeyLayoutFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002482 device->keyMap.keyLayoutFile.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002483 dump += StringPrintf(INDENT3 "KeyCharacterMapFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002484 device->keyMap.keyCharacterMapFile.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002485 dump += StringPrintf(INDENT3 "ConfigurationFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002486 device->configurationFile.c_str());
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002487 dump += INDENT3 "VideoDevice: ";
2488 if (device->videoDevice) {
2489 dump += device->videoDevice->dump() + "\n";
2490 } else {
2491 dump += "<none>\n";
2492 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002493 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002494
2495 dump += INDENT "Unattached video devices:\n";
2496 for (const std::unique_ptr<TouchVideoDevice>& videoDevice : mUnattachedVideoDevices) {
2497 dump += INDENT2 + videoDevice->dump() + "\n";
2498 }
2499 if (mUnattachedVideoDevices.empty()) {
2500 dump += INDENT2 "<none>\n";
2501 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002502 } // release lock
2503}
2504
2505void EventHub::monitor() {
2506 // Acquire and release the lock to ensure that the event hub has not deadlocked.
Chris Ye1c2e0892020-11-30 21:41:44 -08002507 std::unique_lock<std::mutex> lock(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002508}
2509
Michael Wrightd02c5b62014-02-10 15:10:22 -08002510}; // namespace android