blob: 3d3a8ea42d01d5031bb1f09be1e4914d85f4195d [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>
Colin Cross5b799302022-10-18 21:52:41 -070022#include <linux/ioctl.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070023#include <memory.h>
24#include <stdint.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
Siarhei Vishniakou7a522bf2019-09-24 12:46:29 +010028#include <sys/capability.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070029#include <sys/epoll.h>
Mark Salyzyn5aa26b22014-06-10 13:07:44 -070030#include <sys/inotify.h>
31#include <sys/ioctl.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>
Dominik Laskowski75788452021-02-09 18:51:25 -080043#include <ftl/enum.h>
Chris Ye8594e192020-07-14 10:34:06 -070044#include <input/KeyCharacterMap.h>
45#include <input/KeyLayoutMap.h>
Prabir Pradhan07525ef2022-10-03 21:51:26 +000046#include <input/PrintTools.h>
Chris Ye8594e192020-07-14 10:34:06 -070047#include <input/VirtualKeyMap.h>
Dan Albert677d87e2014-06-16 17:31:28 -070048#include <openssl/sha.h>
Chris Yed3fef462021-03-07 17:10:08 -080049#include <statslog.h>
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070050#include <utils/Errors.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080051#include <utils/Log.h>
52#include <utils/Timers.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080053
Chris Ye8594e192020-07-14 10:34:06 -070054#include <filesystem>
Chris Ye3fdbfef2021-01-06 18:45:18 -080055#include <regex>
Prabir Pradhancb42b472022-08-23 16:01:19 +000056#include <utility>
Chris Ye8594e192020-07-14 10:34:06 -070057
58#include "EventHub.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080059
Michael Wrightd02c5b62014-02-10 15:10:22 -080060#define INDENT " "
61#define INDENT2 " "
62#define INDENT3 " "
63
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -080064using android::base::StringPrintf;
65
Michael Wrightd02c5b62014-02-10 15:10:22 -080066namespace android {
67
Dominik Laskowski2f01d772022-03-23 16:01:29 -070068using namespace ftl::flag_operators;
69
Usama Arifb27c8e62021-06-03 16:44:09 +010070static const char* DEVICE_INPUT_PATH = "/dev/input";
Siarhei Vishniakou951f3622018-12-12 19:45:42 -080071// v4l2 devices go directly into /dev
Usama Arifb27c8e62021-06-03 16:44:09 +010072static const char* DEVICE_PATH = "/dev";
Michael Wrightd02c5b62014-02-10 15:10:22 -080073
Chris Ye657c2f02021-05-25 16:24:37 -070074static constexpr size_t OBFUSCATED_LENGTH = 8;
75
Chris Ye87143712020-11-10 05:05:58 +000076static constexpr int32_t FF_STRONG_MAGNITUDE_CHANNEL_IDX = 0;
77static constexpr int32_t FF_WEAK_MAGNITUDE_CHANNEL_IDX = 1;
Chris Ye6393a262020-08-04 19:41:36 -070078
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -070079static constexpr size_t EVENT_BUFFER_SIZE = 256;
80
Chris Yee2b1e5c2021-03-10 22:45:12 -080081// Mapping for input battery class node IDs lookup.
82// https://www.kernel.org/doc/Documentation/power/power_supply_class.txt
83static const std::unordered_map<std::string, InputBatteryClass> BATTERY_CLASSES =
84 {{"capacity", InputBatteryClass::CAPACITY},
85 {"capacity_level", InputBatteryClass::CAPACITY_LEVEL},
86 {"status", InputBatteryClass::STATUS}};
87
88// Mapping for input battery class node names lookup.
89// https://www.kernel.org/doc/Documentation/power/power_supply_class.txt
90static const std::unordered_map<InputBatteryClass, std::string> BATTERY_NODES =
91 {{InputBatteryClass::CAPACITY, "capacity"},
92 {InputBatteryClass::CAPACITY_LEVEL, "capacity_level"},
93 {InputBatteryClass::STATUS, "status"}};
94
Kim Low03ea0352020-11-06 12:45:07 -080095// must be kept in sync with definitions in kernel /drivers/power/supply/power_supply_sysfs.c
96static const std::unordered_map<std::string, int32_t> BATTERY_STATUS =
97 {{"Unknown", BATTERY_STATUS_UNKNOWN},
98 {"Charging", BATTERY_STATUS_CHARGING},
99 {"Discharging", BATTERY_STATUS_DISCHARGING},
100 {"Not charging", BATTERY_STATUS_NOT_CHARGING},
101 {"Full", BATTERY_STATUS_FULL}};
102
103// Mapping taken from
104// https://gitlab.freedesktop.org/upower/upower/-/blob/master/src/linux/up-device-supply.c#L484
105static const std::unordered_map<std::string, int32_t> BATTERY_LEVEL = {{"Critical", 5},
106 {"Low", 10},
107 {"Normal", 55},
108 {"High", 70},
109 {"Full", 100},
110 {"Unknown", 50}};
111
Chris Ye3fdbfef2021-01-06 18:45:18 -0800112// Mapping for input led class node names lookup.
113// https://www.kernel.org/doc/html/latest/leds/leds-class.html
114static const std::unordered_map<std::string, InputLightClass> LIGHT_CLASSES =
115 {{"red", InputLightClass::RED},
116 {"green", InputLightClass::GREEN},
117 {"blue", InputLightClass::BLUE},
118 {"global", InputLightClass::GLOBAL},
119 {"brightness", InputLightClass::BRIGHTNESS},
120 {"multi_index", InputLightClass::MULTI_INDEX},
121 {"multi_intensity", InputLightClass::MULTI_INTENSITY},
Vaibhav Devmurari82b37d62022-09-12 13:36:48 +0000122 {"max_brightness", InputLightClass::MAX_BRIGHTNESS},
123 {"kbd_backlight", InputLightClass::KEYBOARD_BACKLIGHT}};
Chris Ye3fdbfef2021-01-06 18:45:18 -0800124
125// Mapping for input multicolor led class node names.
126// https://www.kernel.org/doc/html/latest/leds/leds-class-multicolor.html
127static const std::unordered_map<InputLightClass, std::string> LIGHT_NODES =
128 {{InputLightClass::BRIGHTNESS, "brightness"},
129 {InputLightClass::MULTI_INDEX, "multi_index"},
130 {InputLightClass::MULTI_INTENSITY, "multi_intensity"}};
131
132// Mapping for light color name and the light color
133const std::unordered_map<std::string, LightColor> LIGHT_COLORS = {{"red", LightColor::RED},
134 {"green", LightColor::GREEN},
135 {"blue", LightColor::BLUE}};
136
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000137// Mapping for country code to Layout info.
138// See bCountryCode in 6.2.1 of https://usb.org/sites/default/files/hid1_11.pdf.
139const std::unordered_map<std::int32_t, RawLayoutInfo> LAYOUT_INFOS =
140 {{0, RawLayoutInfo{.languageTag = "", .layoutType = ""}}, // NOT_SUPPORTED
141 {1, RawLayoutInfo{.languageTag = "ar-Arab", .layoutType = ""}}, // ARABIC
142 {2, RawLayoutInfo{.languageTag = "fr-BE", .layoutType = ""}}, // BELGIAN
143 {3, RawLayoutInfo{.languageTag = "fr-CA", .layoutType = ""}}, // CANADIAN_BILINGUAL
144 {4, RawLayoutInfo{.languageTag = "fr-CA", .layoutType = ""}}, // CANADIAN_FRENCH
145 {5, RawLayoutInfo{.languageTag = "cs", .layoutType = ""}}, // CZECH_REPUBLIC
146 {6, RawLayoutInfo{.languageTag = "da", .layoutType = ""}}, // DANISH
147 {7, RawLayoutInfo{.languageTag = "fi", .layoutType = ""}}, // FINNISH
148 {8, RawLayoutInfo{.languageTag = "fr-FR", .layoutType = ""}}, // FRENCH
149 {9, RawLayoutInfo{.languageTag = "de", .layoutType = ""}}, // GERMAN
150 {10, RawLayoutInfo{.languageTag = "el", .layoutType = ""}}, // GREEK
151 {11, RawLayoutInfo{.languageTag = "iw", .layoutType = ""}}, // HEBREW
152 {12, RawLayoutInfo{.languageTag = "hu", .layoutType = ""}}, // HUNGARY
153 {13, RawLayoutInfo{.languageTag = "en", .layoutType = "extended"}}, // INTERNATIONAL (ISO)
154 {14, RawLayoutInfo{.languageTag = "it", .layoutType = ""}}, // ITALIAN
155 {15, RawLayoutInfo{.languageTag = "ja", .layoutType = ""}}, // JAPAN
156 {16, RawLayoutInfo{.languageTag = "ko", .layoutType = ""}}, // KOREAN
157 {17, RawLayoutInfo{.languageTag = "es-419", .layoutType = ""}}, // LATIN_AMERICA
158 {18, RawLayoutInfo{.languageTag = "nl", .layoutType = ""}}, // DUTCH
159 {19, RawLayoutInfo{.languageTag = "nb", .layoutType = ""}}, // NORWEGIAN
160 {20, RawLayoutInfo{.languageTag = "fa", .layoutType = ""}}, // PERSIAN
161 {21, RawLayoutInfo{.languageTag = "pl", .layoutType = ""}}, // POLAND
162 {22, RawLayoutInfo{.languageTag = "pt", .layoutType = ""}}, // PORTUGUESE
163 {23, RawLayoutInfo{.languageTag = "ru", .layoutType = ""}}, // RUSSIA
164 {24, RawLayoutInfo{.languageTag = "sk", .layoutType = ""}}, // SLOVAKIA
165 {25, RawLayoutInfo{.languageTag = "es-ES", .layoutType = ""}}, // SPANISH
166 {26, RawLayoutInfo{.languageTag = "sv", .layoutType = ""}}, // SWEDISH
167 {27, RawLayoutInfo{.languageTag = "fr-CH", .layoutType = ""}}, // SWISS_FRENCH
168 {28, RawLayoutInfo{.languageTag = "de-CH", .layoutType = ""}}, // SWISS_GERMAN
169 {29, RawLayoutInfo{.languageTag = "de-CH", .layoutType = ""}}, // SWITZERLAND
170 {30, RawLayoutInfo{.languageTag = "zh-TW", .layoutType = ""}}, // TAIWAN
171 {31, RawLayoutInfo{.languageTag = "tr", .layoutType = "turkish_q"}}, // TURKISH_Q
172 {32, RawLayoutInfo{.languageTag = "en-GB", .layoutType = ""}}, // UK
173 {33, RawLayoutInfo{.languageTag = "en-US", .layoutType = ""}}, // US
174 {34, RawLayoutInfo{.languageTag = "", .layoutType = ""}}, // YUGOSLAVIA
175 {35, RawLayoutInfo{.languageTag = "tr", .layoutType = "turkish_f"}}}; // TURKISH_F
176
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100177static std::string sha1(const std::string& in) {
Dan Albert677d87e2014-06-16 17:31:28 -0700178 SHA_CTX ctx;
179 SHA1_Init(&ctx);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100180 SHA1_Update(&ctx, reinterpret_cast<const u_char*>(in.c_str()), in.size());
Dan Albert677d87e2014-06-16 17:31:28 -0700181 u_char digest[SHA_DIGEST_LENGTH];
182 SHA1_Final(digest, &ctx);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800183
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100184 std::string out;
Dan Albert677d87e2014-06-16 17:31:28 -0700185 for (size_t i = 0; i < SHA_DIGEST_LENGTH; i++) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100186 out += StringPrintf("%02x", digest[i]);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800187 }
188 return out;
189}
190
Prabir Pradhana3621852022-10-14 18:57:23 +0000191/* The set of all Android key codes that correspond to buttons (bit-switches) on a stylus. */
192static constexpr std::array<int32_t, 4> STYLUS_BUTTON_KEYCODES = {
193 AKEYCODE_STYLUS_BUTTON_PRIMARY,
194 AKEYCODE_STYLUS_BUTTON_SECONDARY,
195 AKEYCODE_STYLUS_BUTTON_TERTIARY,
196 AKEYCODE_STYLUS_BUTTON_TAIL,
197};
198
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800199/**
200 * Return true if name matches "v4l-touch*"
201 */
Chris Ye8594e192020-07-14 10:34:06 -0700202static bool isV4lTouchNode(std::string name) {
203 return name.find("v4l-touch") != std::string::npos;
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800204}
205
Philip Quinn39b81682019-01-09 22:20:39 -0800206/**
207 * Returns true if V4L devices should be scanned.
208 *
209 * The system property ro.input.video_enabled can be used to control whether
210 * EventHub scans and opens V4L devices. As V4L does not support multiple
211 * clients, EventHub effectively blocks access to these devices when it opens
Siarhei Vishniakou29f88492019-04-05 14:11:43 -0700212 * them.
213 *
214 * Setting this to "false" would prevent any video devices from being discovered and
215 * associated with input devices.
216 *
217 * This property can be used as follows:
218 * 1. To turn off features that are dependent on video device presence.
219 * 2. During testing and development, to allow other clients to read video devices
220 * directly from /dev.
Philip Quinn39b81682019-01-09 22:20:39 -0800221 */
222static bool isV4lScanningEnabled() {
Harry Cutts33476232023-01-30 19:57:29 +0000223 return property_get_bool("ro.input.video_enabled", /*default_value=*/true);
Philip Quinn39b81682019-01-09 22:20:39 -0800224}
225
Siarhei Vishniakou592bac22018-11-08 19:42:38 -0800226static nsecs_t processEventTimestamp(const struct input_event& event) {
227 // Use the time specified in the event instead of the current time
228 // so that downstream code can get more accurate estimates of
229 // event dispatch latency from the time the event is enqueued onto
230 // the evdev client buffer.
231 //
232 // The event's timestamp fortuitously uses the same monotonic clock
233 // time base as the rest of Android. The kernel event device driver
234 // (drivers/input/evdev.c) obtains timestamps using ktime_get_ts().
235 // The systemTime(SYSTEM_TIME_MONOTONIC) function we use everywhere
236 // calls clock_gettime(CLOCK_MONOTONIC) which is implemented as a
237 // system call that also queries ktime_get_ts().
238
Colin Cross5b799302022-10-18 21:52:41 -0700239 const nsecs_t inputEventTime = seconds_to_nanoseconds(event.input_event_sec) +
240 microseconds_to_nanoseconds(event.input_event_usec);
Siarhei Vishniakou592bac22018-11-08 19:42:38 -0800241 return inputEventTime;
242}
243
Kim Low03ea0352020-11-06 12:45:07 -0800244/**
Prabir Pradhancb42b472022-08-23 16:01:19 +0000245 * Returns the sysfs root path of the input device.
Kim Low03ea0352020-11-06 12:45:07 -0800246 */
Chris Ye3fdbfef2021-01-06 18:45:18 -0800247static std::optional<std::filesystem::path> getSysfsRootPath(const char* devicePath) {
Kim Low03ea0352020-11-06 12:45:07 -0800248 std::error_code errorCode;
249
250 // Stat the device path to get the major and minor number of the character file
251 struct stat statbuf;
252 if (stat(devicePath, &statbuf) == -1) {
253 ALOGE("Could not stat device %s due to error: %s.", devicePath, std::strerror(errno));
Chris Ye3fdbfef2021-01-06 18:45:18 -0800254 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800255 }
256
257 unsigned int major_num = major(statbuf.st_rdev);
258 unsigned int minor_num = minor(statbuf.st_rdev);
259
260 // Realpath "/sys/dev/char/{major}:{minor}" to get the sysfs path to the input event
261 auto sysfsPath = std::filesystem::path("/sys/dev/char/");
262 sysfsPath /= std::to_string(major_num) + ":" + std::to_string(minor_num);
263 sysfsPath = std::filesystem::canonical(sysfsPath, errorCode);
264
265 // Make sure nothing went wrong in call to canonical()
266 if (errorCode) {
267 ALOGW("Could not run filesystem::canonical() due to error %d : %s.", errorCode.value(),
268 errorCode.message().c_str());
Chris Ye3fdbfef2021-01-06 18:45:18 -0800269 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800270 }
271
272 // Continue to go up a directory until we reach a directory named "input"
273 while (sysfsPath != "/" && sysfsPath.filename() != "input") {
274 sysfsPath = sysfsPath.parent_path();
275 }
276
277 // Then go up one more and you will be at the sysfs root of the device
278 sysfsPath = sysfsPath.parent_path();
279
280 // Make sure we didn't reach root path and that directory actually exists
281 if (sysfsPath == "/" || !std::filesystem::exists(sysfsPath, errorCode)) {
282 if (errorCode) {
283 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
284 errorCode.message().c_str());
285 }
286
287 // Not found
Chris Ye3fdbfef2021-01-06 18:45:18 -0800288 return std::nullopt;
Kim Low03ea0352020-11-06 12:45:07 -0800289 }
290
291 return sysfsPath;
292}
293
294/**
Chris Ye3fdbfef2021-01-06 18:45:18 -0800295 * Returns the list of files under a specified path.
Kim Low03ea0352020-11-06 12:45:07 -0800296 */
Chris Ye3fdbfef2021-01-06 18:45:18 -0800297static std::vector<std::filesystem::path> allFilesInPath(const std::filesystem::path& path) {
298 std::vector<std::filesystem::path> nodes;
299 std::error_code errorCode;
300 auto iter = std::filesystem::directory_iterator(path, errorCode);
301 while (!errorCode && iter != std::filesystem::directory_iterator()) {
302 nodes.push_back(iter->path());
303 iter++;
304 }
305 return nodes;
306}
307
308/**
309 * Returns the list of files under a specified directory in a sysfs path.
310 * Example:
311 * findSysfsNodes(sysfsRootPath, SysfsClass::LEDS) will return all led nodes under "leds" directory
312 * in the sysfs path.
313 */
314static std::vector<std::filesystem::path> findSysfsNodes(const std::filesystem::path& sysfsRoot,
315 SysfsClass clazz) {
Dominik Laskowski75788452021-02-09 18:51:25 -0800316 std::string nodeStr = ftl::enum_string(clazz);
Chris Ye3fdbfef2021-01-06 18:45:18 -0800317 std::for_each(nodeStr.begin(), nodeStr.end(),
318 [](char& c) { c = std::tolower(static_cast<unsigned char>(c)); });
319 std::vector<std::filesystem::path> nodes;
320 for (auto path = sysfsRoot; path != "/" && nodes.empty(); path = path.parent_path()) {
321 nodes = allFilesInPath(path / nodeStr);
322 }
323 return nodes;
324}
325
326static std::optional<std::array<LightColor, COLOR_NUM>> getColorIndexArray(
327 std::filesystem::path path) {
328 std::string indexStr;
329 if (!base::ReadFileToString(path, &indexStr)) {
330 return std::nullopt;
331 }
332
333 // Parse the multi color LED index file, refer to kernel docs
334 // leds/leds-class-multicolor.html
335 std::regex indexPattern("(red|green|blue)\\s(red|green|blue)\\s(red|green|blue)[\\n]");
336 std::smatch results;
337 std::array<LightColor, COLOR_NUM> colors;
338 if (!std::regex_match(indexStr, results, indexPattern)) {
339 return std::nullopt;
340 }
341
342 for (size_t i = 1; i < results.size(); i++) {
343 const auto it = LIGHT_COLORS.find(results[i].str());
344 if (it != LIGHT_COLORS.end()) {
345 // intensities.emplace(it->second, 0);
346 colors[i - 1] = it->second;
Kim Low03ea0352020-11-06 12:45:07 -0800347 }
348 }
Chris Ye3fdbfef2021-01-06 18:45:18 -0800349 return colors;
Kim Low03ea0352020-11-06 12:45:07 -0800350}
351
Prabir Pradhancb42b472022-08-23 16:01:19 +0000352/**
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000353 * Read country code information exposed through the sysfs path and convert it to Layout info.
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000354 */
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000355static std::optional<RawLayoutInfo> readLayoutConfiguration(
356 const std::filesystem::path& sysfsRootPath) {
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000357 // Check the sysfs root path
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000358 int32_t hidCountryCode = -1;
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000359 std::string str;
360 if (base::ReadFileToString(sysfsRootPath / "country", &str)) {
361 hidCountryCode = std::stoi(str, nullptr, 16);
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000362 // Update this condition if new supported country codes are added to HID spec.
Vaibhav Devmurari990ff7b2022-12-22 18:23:21 +0000363 if (hidCountryCode > 35 || hidCountryCode < 0) {
364 ALOGE("HID country code should be in range [0, 35], but for sysfs path %s it was %d",
365 sysfsRootPath.c_str(), hidCountryCode);
Vaibhav Devmurari990ff7b2022-12-22 18:23:21 +0000366 }
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000367 }
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000368 const auto it = LAYOUT_INFOS.find(hidCountryCode);
369 if (it != LAYOUT_INFOS.end()) {
370 return it->second;
371 }
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000372
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000373 return std::nullopt;
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +0000374}
375
376/**
Prabir Pradhancb42b472022-08-23 16:01:19 +0000377 * Read information about batteries exposed through the sysfs path.
378 */
379static std::unordered_map<int32_t /*batteryId*/, RawBatteryInfo> readBatteryConfiguration(
380 const std::filesystem::path& sysfsRootPath) {
381 std::unordered_map<int32_t, RawBatteryInfo> batteryInfos;
382 int32_t nextBatteryId = 0;
383 // Check if device has any battery.
384 const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::POWER_SUPPLY);
385 for (const auto& nodePath : paths) {
386 RawBatteryInfo info;
387 info.id = ++nextBatteryId;
388 info.path = nodePath;
389 info.name = nodePath.filename();
390
391 // Scan the path for all the files
392 // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt
393 const auto& files = allFilesInPath(nodePath);
394 for (const auto& file : files) {
395 const auto it = BATTERY_CLASSES.find(file.filename().string());
396 if (it != BATTERY_CLASSES.end()) {
397 info.flags |= it->second;
398 }
399 }
400 batteryInfos.insert_or_assign(info.id, info);
401 ALOGD("configureBatteryLocked rawBatteryId %d name %s", info.id, info.name.c_str());
402 }
403 return batteryInfos;
404}
405
406/**
407 * Read information about lights exposed through the sysfs path.
408 */
409static std::unordered_map<int32_t /*lightId*/, RawLightInfo> readLightsConfiguration(
410 const std::filesystem::path& sysfsRootPath) {
411 std::unordered_map<int32_t, RawLightInfo> lightInfos;
412 int32_t nextLightId = 0;
413 // Check if device has any lights.
414 const auto& paths = findSysfsNodes(sysfsRootPath, SysfsClass::LEDS);
415 for (const auto& nodePath : paths) {
416 RawLightInfo info;
417 info.id = ++nextLightId;
418 info.path = nodePath;
419 info.name = nodePath.filename();
420 info.maxBrightness = std::nullopt;
Vaibhav Devmurari82b37d62022-09-12 13:36:48 +0000421
422 // Light name should follow the naming pattern <name>:<color>:<function>
423 // Refer kernel docs /leds/leds-class.html for valid supported LED names.
424 std::regex indexPattern("([a-zA-Z0-9_.:]*:)?([a-zA-Z0-9_.]*):([a-zA-Z0-9_.]*)");
425 std::smatch results;
426
427 if (std::regex_match(info.name, results, indexPattern)) {
428 // regex_match will return full match at index 0 and <name> at index 1. For RawLightInfo
429 // we only care about sections <color> and <function> which will be at index 2 and 3.
430 for (int i = 2; i <= 3; i++) {
431 const auto it = LIGHT_CLASSES.find(results.str(i));
432 if (it != LIGHT_CLASSES.end()) {
433 info.flags |= it->second;
434 }
Prabir Pradhancb42b472022-08-23 16:01:19 +0000435 }
Vaibhav Devmurari82b37d62022-09-12 13:36:48 +0000436
437 // Set name of the raw light to <function> which represents playerIDs for LEDs that
438 // turn on/off based on the current player ID (Refer to PeripheralController.cpp for
439 // player ID logic)
440 info.name = results.str(3);
Prabir Pradhancb42b472022-08-23 16:01:19 +0000441 }
442 // Scan the path for all the files
443 // Refer to https://www.kernel.org/doc/Documentation/leds/leds-class.txt
444 const auto& files = allFilesInPath(nodePath);
445 for (const auto& file : files) {
446 const auto it = LIGHT_CLASSES.find(file.filename().string());
447 if (it != LIGHT_CLASSES.end()) {
448 info.flags |= it->second;
449 // If the node has maximum brightness, read it
450 if (it->second == InputLightClass::MAX_BRIGHTNESS) {
451 std::string str;
452 if (base::ReadFileToString(file, &str)) {
453 info.maxBrightness = std::stoi(str);
454 }
455 }
456 }
457 }
458 lightInfos.insert_or_assign(info.id, info);
459 ALOGD("configureLightsLocked rawLightId %d name %s", info.id, info.name.c_str());
460 }
461 return lightInfos;
462}
463
Michael Wrightd02c5b62014-02-10 15:10:22 -0800464// --- Global Functions ---
465
Dominik Laskowski2f01d772022-03-23 16:01:29 -0700466ftl::Flags<InputDeviceClass> getAbsAxisUsage(int32_t axis,
467 ftl::Flags<InputDeviceClass> deviceClasses) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800468 // Touch devices get dibs on touch-related axes.
Chris Ye1b0c7342020-07-28 21:57:03 -0700469 if (deviceClasses.test(InputDeviceClass::TOUCH)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800470 switch (axis) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700471 case ABS_X:
472 case ABS_Y:
473 case ABS_PRESSURE:
474 case ABS_TOOL_WIDTH:
475 case ABS_DISTANCE:
476 case ABS_TILT_X:
477 case ABS_TILT_Y:
478 case ABS_MT_SLOT:
479 case ABS_MT_TOUCH_MAJOR:
480 case ABS_MT_TOUCH_MINOR:
481 case ABS_MT_WIDTH_MAJOR:
482 case ABS_MT_WIDTH_MINOR:
483 case ABS_MT_ORIENTATION:
484 case ABS_MT_POSITION_X:
485 case ABS_MT_POSITION_Y:
486 case ABS_MT_TOOL_TYPE:
487 case ABS_MT_BLOB_ID:
488 case ABS_MT_TRACKING_ID:
489 case ABS_MT_PRESSURE:
490 case ABS_MT_DISTANCE:
Chris Ye1b0c7342020-07-28 21:57:03 -0700491 return InputDeviceClass::TOUCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800492 }
493 }
494
Chris Yef59a2f42020-10-16 12:55:26 -0700495 if (deviceClasses.test(InputDeviceClass::SENSOR)) {
496 switch (axis) {
497 case ABS_X:
498 case ABS_Y:
499 case ABS_Z:
500 case ABS_RX:
501 case ABS_RY:
502 case ABS_RZ:
503 return InputDeviceClass::SENSOR;
504 }
505 }
506
Michael Wright842500e2015-03-13 17:32:02 -0700507 // External stylus gets the pressure axis
Chris Ye1b0c7342020-07-28 21:57:03 -0700508 if (deviceClasses.test(InputDeviceClass::EXTERNAL_STYLUS)) {
Michael Wright842500e2015-03-13 17:32:02 -0700509 if (axis == ABS_PRESSURE) {
Chris Ye1b0c7342020-07-28 21:57:03 -0700510 return InputDeviceClass::EXTERNAL_STYLUS;
Michael Wright842500e2015-03-13 17:32:02 -0700511 }
512 }
513
Michael Wrightd02c5b62014-02-10 15:10:22 -0800514 // Joystick devices get the rest.
Chris Ye1b0c7342020-07-28 21:57:03 -0700515 return deviceClasses & InputDeviceClass::JOYSTICK;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800516}
517
Harry Cuttsea73eaa2023-01-16 17:55:46 +0000518// --- RawAbsoluteAxisInfo ---
519
520std::ostream& operator<<(std::ostream& out, const RawAbsoluteAxisInfo& info) {
521 if (info.valid) {
522 out << "min=" << info.minValue << ", max=" << info.maxValue << ", flat=" << info.flat
523 << ", fuzz=" << info.fuzz << ", resolution=" << info.resolution;
524 } else {
525 out << "unknown range";
526 }
527 return out;
528}
529
Michael Wrightd02c5b62014-02-10 15:10:22 -0800530// --- EventHub::Device ---
531
Prabir Pradhancb42b472022-08-23 16:01:19 +0000532EventHub::Device::Device(int fd, int32_t id, std::string path, InputDeviceIdentifier identifier,
533 std::shared_ptr<const AssociatedDevice> assocDev)
Chris Ye989bb932020-07-04 16:18:59 -0700534 : fd(fd),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700535 id(id),
Prabir Pradhancb42b472022-08-23 16:01:19 +0000536 path(std::move(path)),
537 identifier(std::move(identifier)),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700538 classes(0),
539 configuration(nullptr),
540 virtualKeyMap(nullptr),
541 ffEffectPlaying(false),
542 ffEffectId(-1),
Prabir Pradhancb42b472022-08-23 16:01:19 +0000543 associatedDevice(std::move(assocDev)),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700544 controllerNumber(0),
545 enabled(true),
Chris Ye66fbac32020-07-06 20:36:43 -0700546 isVirtual(fd < 0) {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800547
548EventHub::Device::~Device() {
549 close();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800550}
551
552void EventHub::Device::close() {
553 if (fd >= 0) {
554 ::close(fd);
555 fd = -1;
556 }
557}
558
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700559status_t EventHub::Device::enable() {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100560 fd = open(path.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700561 if (fd < 0) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100562 ALOGE("could not open %s, %s\n", path.c_str(), strerror(errno));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700563 return -errno;
564 }
565 enabled = true;
566 return OK;
567}
568
569status_t EventHub::Device::disable() {
570 close();
571 enabled = false;
572 return OK;
573}
574
Chris Ye989bb932020-07-04 16:18:59 -0700575bool EventHub::Device::hasValidFd() const {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700576 return !isVirtual && enabled;
577}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800578
Chris Ye3a1e4462020-08-12 10:13:15 -0700579const std::shared_ptr<KeyCharacterMap> EventHub::Device::getKeyCharacterMap() const {
Chris Ye989bb932020-07-04 16:18:59 -0700580 return keyMap.keyCharacterMap;
581}
582
583template <std::size_t N>
584status_t EventHub::Device::readDeviceBitMask(unsigned long ioctlCode, BitArray<N>& bitArray) {
585 if (!hasValidFd()) {
586 return BAD_VALUE;
587 }
588 if ((_IOC_SIZE(ioctlCode) == 0)) {
589 ioctlCode |= _IOC(0, 0, 0, bitArray.bytes());
590 }
591
592 typename BitArray<N>::Buffer buffer;
593 status_t ret = ioctl(fd, ioctlCode, buffer.data());
594 bitArray.loadFromBuffer(buffer);
595 return ret;
596}
597
598void EventHub::Device::configureFd() {
599 // Set fd parameters with ioctl, such as key repeat, suspend block, and clock type
600 if (classes.test(InputDeviceClass::KEYBOARD)) {
601 // Disable kernel key repeat since we handle it ourselves
602 unsigned int repeatRate[] = {0, 0};
603 if (ioctl(fd, EVIOCSREP, repeatRate)) {
604 ALOGW("Unable to disable kernel key repeat for %s: %s", path.c_str(), strerror(errno));
605 }
606 }
607
608 // Tell the kernel that we want to use the monotonic clock for reporting timestamps
609 // associated with input events. This is important because the input system
610 // uses the timestamps extensively and assumes they were recorded using the monotonic
611 // clock.
612 int clockId = CLOCK_MONOTONIC;
Chris Yef59a2f42020-10-16 12:55:26 -0700613 if (classes.test(InputDeviceClass::SENSOR)) {
614 // Each new sensor event should use the same time base as
615 // SystemClock.elapsedRealtimeNanos().
616 clockId = CLOCK_BOOTTIME;
617 }
Chris Ye989bb932020-07-04 16:18:59 -0700618 bool usingClockIoctl = !ioctl(fd, EVIOCSCLOCKID, &clockId);
619 ALOGI("usingClockIoctl=%s", toString(usingClockIoctl));
620}
621
622bool EventHub::Device::hasKeycodeLocked(int keycode) const {
623 if (!keyMap.haveKeyLayout()) {
624 return false;
625 }
626
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -0700627 std::vector<int32_t> scanCodes = keyMap.keyLayoutMap->findScanCodesForKey(keycode);
Chris Ye989bb932020-07-04 16:18:59 -0700628 const size_t N = scanCodes.size();
629 for (size_t i = 0; i < N && i <= KEY_MAX; i++) {
630 int32_t sc = scanCodes[i];
631 if (sc >= 0 && sc <= KEY_MAX && keyBitmask.test(sc)) {
632 return true;
633 }
634 }
635
636 return false;
637}
638
639void EventHub::Device::loadConfigurationLocked() {
640 configurationFile =
641 getInputDeviceConfigurationFilePathByDeviceIdentifier(identifier,
642 InputDeviceConfigurationFileType::
643 CONFIGURATION);
644 if (configurationFile.empty()) {
645 ALOGD("No input device configuration file found for device '%s'.", identifier.name.c_str());
646 } else {
Siarhei Vishniakou4d9f9772020-09-02 22:28:29 -0500647 android::base::Result<std::unique_ptr<PropertyMap>> propertyMap =
648 PropertyMap::load(configurationFile.c_str());
649 if (!propertyMap.ok()) {
Chris Ye989bb932020-07-04 16:18:59 -0700650 ALOGE("Error loading input device configuration file for device '%s'. "
651 "Using default configuration.",
652 identifier.name.c_str());
Siarhei Vishniakoud549b252020-08-11 11:25:26 -0500653 } else {
Siarhei Vishniakou4d9f9772020-09-02 22:28:29 -0500654 configuration = std::move(*propertyMap);
Chris Ye989bb932020-07-04 16:18:59 -0700655 }
656 }
657}
658
659bool EventHub::Device::loadVirtualKeyMapLocked() {
660 // The virtual key map is supplied by the kernel as a system board property file.
661 std::string propPath = "/sys/board_properties/virtualkeys.";
662 propPath += identifier.getCanonicalName();
663 if (access(propPath.c_str(), R_OK)) {
664 return false;
665 }
666 virtualKeyMap = VirtualKeyMap::load(propPath);
667 return virtualKeyMap != nullptr;
668}
669
670status_t EventHub::Device::loadKeyMapLocked() {
Siarhei Vishniakoud549b252020-08-11 11:25:26 -0500671 return keyMap.load(identifier, configuration.get());
Chris Ye989bb932020-07-04 16:18:59 -0700672}
673
674bool EventHub::Device::isExternalDeviceLocked() {
675 if (configuration) {
676 bool value;
Siarhei Vishniakou4f94c1a2022-07-13 07:29:51 -0700677 if (configuration->tryGetProperty("device.internal", value)) {
Chris Ye989bb932020-07-04 16:18:59 -0700678 return !value;
679 }
680 }
681 return identifier.bus == BUS_USB || identifier.bus == BUS_BLUETOOTH;
682}
683
684bool EventHub::Device::deviceHasMicLocked() {
685 if (configuration) {
686 bool value;
Siarhei Vishniakou4f94c1a2022-07-13 07:29:51 -0700687 if (configuration->tryGetProperty("audio.mic", value)) {
Chris Ye989bb932020-07-04 16:18:59 -0700688 return value;
689 }
690 }
691 return false;
692}
693
694void EventHub::Device::setLedStateLocked(int32_t led, bool on) {
695 int32_t sc;
696 if (hasValidFd() && mapLed(led, &sc) != NAME_NOT_FOUND) {
697 struct input_event ev;
Colin Cross5b799302022-10-18 21:52:41 -0700698 ev.input_event_sec = 0;
699 ev.input_event_usec = 0;
Chris Ye989bb932020-07-04 16:18:59 -0700700 ev.type = EV_LED;
701 ev.code = sc;
702 ev.value = on ? 1 : 0;
703
704 ssize_t nWrite;
705 do {
706 nWrite = write(fd, &ev, sizeof(struct input_event));
707 } while (nWrite == -1 && errno == EINTR);
708 }
709}
710
711void EventHub::Device::setLedForControllerLocked() {
712 for (int i = 0; i < MAX_CONTROLLER_LEDS; i++) {
713 setLedStateLocked(ALED_CONTROLLER_1 + i, controllerNumber == i + 1);
714 }
715}
716
717status_t EventHub::Device::mapLed(int32_t led, int32_t* outScanCode) const {
718 if (!keyMap.haveKeyLayout()) {
719 return NAME_NOT_FOUND;
720 }
721
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -0700722 std::optional<int32_t> scanCode = keyMap.keyLayoutMap->findScanCodeForLed(led);
723 if (scanCode.has_value()) {
724 if (*scanCode >= 0 && *scanCode <= LED_MAX && ledBitmask.test(*scanCode)) {
725 *outScanCode = *scanCode;
Chris Ye989bb932020-07-04 16:18:59 -0700726 return NO_ERROR;
727 }
728 }
729 return NAME_NOT_FOUND;
730}
731
Siarhei Vishniakou7a522bf2019-09-24 12:46:29 +0100732/**
733 * Get the capabilities for the current process.
734 * Crashes the system if unable to create / check / destroy the capabilities object.
735 */
736class Capabilities final {
737public:
738 explicit Capabilities() {
739 mCaps = cap_get_proc();
740 LOG_ALWAYS_FATAL_IF(mCaps == nullptr, "Could not get capabilities of the current process");
741 }
742
743 /**
744 * Check whether the current process has a specific capability
745 * in the set of effective capabilities.
746 * Return CAP_SET if the process has the requested capability
747 * Return CAP_CLEAR otherwise.
748 */
749 cap_flag_value_t checkEffectiveCapability(cap_value_t capability) {
750 cap_flag_value_t value;
751 const int result = cap_get_flag(mCaps, capability, CAP_EFFECTIVE, &value);
752 LOG_ALWAYS_FATAL_IF(result == -1, "Could not obtain the requested capability");
753 return value;
754 }
755
756 ~Capabilities() {
757 const int result = cap_free(mCaps);
758 LOG_ALWAYS_FATAL_IF(result == -1, "Could not release the capabilities structure");
759 }
760
761private:
762 cap_t mCaps;
763};
764
765static void ensureProcessCanBlockSuspend() {
766 Capabilities capabilities;
767 const bool canBlockSuspend =
768 capabilities.checkEffectiveCapability(CAP_BLOCK_SUSPEND) == CAP_SET;
769 LOG_ALWAYS_FATAL_IF(!canBlockSuspend,
770 "Input must be able to block suspend to properly process events");
771}
772
Michael Wrightd02c5b62014-02-10 15:10:22 -0800773// --- EventHub ---
774
Michael Wrightd02c5b62014-02-10 15:10:22 -0800775const int EventHub::EPOLL_MAX_EVENTS;
776
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700777EventHub::EventHub(void)
778 : mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD),
779 mNextDeviceId(1),
780 mControllerNumbers(),
Michael Wrightd02c5b62014-02-10 15:10:22 -0800781 mNeedToSendFinishedDeviceScan(false),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700782 mNeedToReopenDevices(false),
783 mNeedToScanDevices(true),
784 mPendingEventCount(0),
785 mPendingEventIndex(0),
786 mPendingINotify(false) {
Siarhei Vishniakou7a522bf2019-09-24 12:46:29 +0100787 ensureProcessCanBlockSuspend();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800788
Nick Kralevichfcf1b2b2018-12-15 11:59:30 -0800789 mEpollFd = epoll_create1(EPOLL_CLOEXEC);
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800790 LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance: %s", strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -0800791
Michael Wright8e9a8562022-02-09 13:44:29 +0000792 mINotifyFd = inotify_init1(IN_CLOEXEC);
Prabir Pradhan952e65b2022-06-23 17:49:55 +0000793 LOG_ALWAYS_FATAL_IF(mINotifyFd < 0, "Could not create inotify instance: %s", strerror(errno));
Usama Arifb27c8e62021-06-03 16:44:09 +0100794
795 std::error_code errorCode;
796 bool isDeviceInotifyAdded = false;
797 if (std::filesystem::exists(DEVICE_INPUT_PATH, errorCode)) {
798 addDeviceInputInotify();
Philip Quinn39b81682019-01-09 22:20:39 -0800799 } else {
Usama Arifb27c8e62021-06-03 16:44:09 +0100800 addDeviceInotify();
801 isDeviceInotifyAdded = true;
802 if (errorCode) {
803 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
804 errorCode.message().c_str());
805 }
806 }
807
808 if (isV4lScanningEnabled() && !isDeviceInotifyAdded) {
809 addDeviceInotify();
810 } else {
Philip Quinn39b81682019-01-09 22:20:39 -0800811 ALOGI("Video device scanning disabled");
812 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800813
Siarhei Vishniakou2d0e9482019-09-24 12:52:47 +0100814 struct epoll_event eventItem = {};
815 eventItem.events = EPOLLIN | EPOLLWAKEUP;
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -0700816 eventItem.data.fd = mINotifyFd;
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800817 int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800818 LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno);
819
820 int wakeFds[2];
Michael Wright8e9a8562022-02-09 13:44:29 +0000821 result = pipe2(wakeFds, O_CLOEXEC);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800822 LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno);
823
824 mWakeReadPipeFd = wakeFds[0];
825 mWakeWritePipeFd = wakeFds[1];
826
827 result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
828 LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700829 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800830
831 result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
832 LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700833 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800834
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -0700835 eventItem.data.fd = mWakeReadPipeFd;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800836 result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
837 LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700838 errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800839}
840
841EventHub::~EventHub(void) {
842 closeAllDevicesLocked();
843
Michael Wrightd02c5b62014-02-10 15:10:22 -0800844 ::close(mEpollFd);
845 ::close(mINotifyFd);
846 ::close(mWakeReadPipeFd);
847 ::close(mWakeWritePipeFd);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800848}
849
Usama Arifb27c8e62021-06-03 16:44:09 +0100850/**
851 * On devices that don't have any input devices (like some development boards), the /dev/input
852 * directory will be absent. However, the user may still plug in an input device at a later time.
853 * Add watch for contents of /dev/input only when /dev/input appears.
854 */
855void EventHub::addDeviceInputInotify() {
856 mDeviceInputWd = inotify_add_watch(mINotifyFd, DEVICE_INPUT_PATH, IN_DELETE | IN_CREATE);
857 LOG_ALWAYS_FATAL_IF(mDeviceInputWd < 0, "Could not register INotify for %s: %s",
858 DEVICE_INPUT_PATH, strerror(errno));
859}
860
861void EventHub::addDeviceInotify() {
862 mDeviceWd = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
863 LOG_ALWAYS_FATAL_IF(mDeviceWd < 0, "Could not register INotify for %s: %s", DEVICE_PATH,
864 strerror(errno));
865}
866
Michael Wrightd02c5b62014-02-10 15:10:22 -0800867InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000868 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800869 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700870 return device != nullptr ? device->identifier : InputDeviceIdentifier();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800871}
872
Dominik Laskowski2f01d772022-03-23 16:01:29 -0700873ftl::Flags<InputDeviceClass> EventHub::getDeviceClasses(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000874 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800875 Device* device = getDeviceLocked(deviceId);
Dominik Laskowski2f01d772022-03-23 16:01:29 -0700876 return device != nullptr ? device->classes : ftl::Flags<InputDeviceClass>(0);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800877}
878
879int32_t EventHub::getDeviceControllerNumber(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000880 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800881 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -0700882 return device != nullptr ? device->controllerNumber : 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800883}
884
Harry Cuttsc34f7582023-03-07 16:23:30 +0000885std::optional<PropertyMap> EventHub::getConfiguration(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +0000886 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800887 Device* device = getDeviceLocked(deviceId);
Harry Cuttsc34f7582023-03-07 16:23:30 +0000888 if (device == nullptr || device->configuration == nullptr) {
889 return {};
Michael Wrightd02c5b62014-02-10 15:10:22 -0800890 }
Harry Cuttsc34f7582023-03-07 16:23:30 +0000891 return *device->configuration;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800892}
893
894status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700895 RawAbsoluteAxisInfo* outAxisInfo) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800896 outAxisInfo->clear();
897
898 if (axis >= 0 && axis <= ABS_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000899 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800900
901 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700902 if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800903 struct input_absinfo info;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700904 if (ioctl(device->fd, EVIOCGABS(axis), &info)) {
905 ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis,
906 device->identifier.name.c_str(), device->fd, errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800907 return -errno;
908 }
909
910 if (info.minimum != info.maximum) {
911 outAxisInfo->valid = true;
912 outAxisInfo->minValue = info.minimum;
913 outAxisInfo->maxValue = info.maximum;
914 outAxisInfo->flat = info.flat;
915 outAxisInfo->fuzz = info.fuzz;
916 outAxisInfo->resolution = info.resolution;
917 }
918 return OK;
919 }
920 }
921 return -1;
922}
923
924bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
925 if (axis >= 0 && axis <= REL_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000926 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800927 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700928 return device != nullptr ? device->relBitmask.test(axis) : false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800929 }
930 return false;
931}
932
933bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
Chris Ye87143712020-11-10 05:05:58 +0000934 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800935
Chris Ye989bb932020-07-04 16:18:59 -0700936 Device* device = getDeviceLocked(deviceId);
937 return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr
938 ? device->propBitmask.test(property)
939 : false;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800940}
941
Chris Yef59a2f42020-10-16 12:55:26 -0700942bool EventHub::hasMscEvent(int32_t deviceId, int mscEvent) const {
943 std::scoped_lock _l(mLock);
944
945 Device* device = getDeviceLocked(deviceId);
946 return mscEvent >= 0 && mscEvent <= MSC_MAX && device != nullptr
947 ? device->mscBitmask.test(mscEvent)
948 : false;
949}
950
Michael Wrightd02c5b62014-02-10 15:10:22 -0800951int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
952 if (scanCode >= 0 && scanCode <= KEY_MAX) {
Chris Ye87143712020-11-10 05:05:58 +0000953 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800954
955 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700956 if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) {
957 if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {
958 return device->keyState.test(scanCode) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800959 }
960 }
961 }
962 return AKEY_STATE_UNKNOWN;
963}
964
965int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
Chris Ye87143712020-11-10 05:05:58 +0000966 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800967
968 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -0700969 if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) {
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -0700970 std::vector<int32_t> scanCodes = device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800971 if (scanCodes.size() != 0) {
Chris Ye66fbac32020-07-06 20:36:43 -0700972 if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800973 for (size_t i = 0; i < scanCodes.size(); i++) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800974 int32_t sc = scanCodes[i];
Chris Ye66fbac32020-07-06 20:36:43 -0700975 if (sc >= 0 && sc <= KEY_MAX && device->keyState.test(sc)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800976 return AKEY_STATE_DOWN;
977 }
978 }
979 return AKEY_STATE_UP;
980 }
981 }
982 }
983 return AKEY_STATE_UNKNOWN;
984}
985
Philip Junker4af3b3d2021-12-14 10:36:55 +0100986int32_t EventHub::getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKeyCode) const {
987 std::scoped_lock _l(mLock);
988
989 Device* device = getDeviceLocked(deviceId);
990 if (device == nullptr || !device->hasValidFd() || device->keyMap.keyCharacterMap == nullptr ||
991 device->keyMap.keyLayoutMap == nullptr) {
992 return AKEYCODE_UNKNOWN;
993 }
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -0700994 std::vector<int32_t> scanCodes =
995 device->keyMap.keyLayoutMap->findScanCodesForKey(locationKeyCode);
Philip Junker4af3b3d2021-12-14 10:36:55 +0100996 if (scanCodes.empty()) {
997 ALOGW("Failed to get key code for key location: no scan code maps to key code %d for input"
998 "device %d",
999 locationKeyCode, deviceId);
1000 return AKEYCODE_UNKNOWN;
1001 }
1002 if (scanCodes.size() > 1) {
1003 ALOGW("Multiple scan codes map to the same key code %d, returning only the first match",
1004 locationKeyCode);
1005 }
1006 int32_t outKeyCode;
1007 status_t mapKeyRes =
Harry Cutts33476232023-01-30 19:57:29 +00001008 device->getKeyCharacterMap()->mapKey(scanCodes[0], /*usageCode=*/0, &outKeyCode);
Philip Junker4af3b3d2021-12-14 10:36:55 +01001009 switch (mapKeyRes) {
1010 case OK:
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001011 break;
Philip Junker4af3b3d2021-12-14 10:36:55 +01001012 case NAME_NOT_FOUND:
1013 // key character map doesn't re-map this scanCode, hence the keyCode remains the same
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001014 outKeyCode = locationKeyCode;
1015 break;
Philip Junker4af3b3d2021-12-14 10:36:55 +01001016 default:
1017 ALOGW("Failed to get key code for key location: Key character map returned error %s",
1018 statusToString(mapKeyRes).c_str());
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001019 outKeyCode = AKEYCODE_UNKNOWN;
1020 break;
Philip Junker4af3b3d2021-12-14 10:36:55 +01001021 }
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001022 // Remap if there is a Key remapping added to the KCM and return the remapped key
1023 return device->getKeyCharacterMap()->applyKeyRemapping(outKeyCode);
Philip Junker4af3b3d2021-12-14 10:36:55 +01001024}
1025
Michael Wrightd02c5b62014-02-10 15:10:22 -08001026int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
1027 if (sw >= 0 && sw <= SW_MAX) {
Chris Ye87143712020-11-10 05:05:58 +00001028 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001029
1030 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001031 if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) {
1032 if (device->readDeviceBitMask(EVIOCGSW(0), device->swState) >= 0) {
1033 return device->swState.test(sw) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001034 }
1035 }
1036 }
1037 return AKEY_STATE_UNKNOWN;
1038}
1039
1040status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const {
1041 *outValue = 0;
1042
1043 if (axis >= 0 && axis <= ABS_MAX) {
Chris Ye87143712020-11-10 05:05:58 +00001044 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001045
1046 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001047 if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001048 struct input_absinfo info;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001049 if (ioctl(device->fd, EVIOCGABS(axis), &info)) {
1050 ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", axis,
1051 device->identifier.name.c_str(), device->fd, errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001052 return -errno;
1053 }
1054
1055 *outValue = info.value;
1056 return OK;
1057 }
1058 }
1059 return -1;
1060}
1061
Siarhei Vishniakou74007942022-06-13 13:57:47 -07001062bool EventHub::markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001063 uint8_t* outFlags) const {
Chris Ye87143712020-11-10 05:05:58 +00001064 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001065
1066 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001067 if (device != nullptr && device->keyMap.haveKeyLayout()) {
Siarhei Vishniakou74007942022-06-13 13:57:47 -07001068 for (size_t codeIndex = 0; codeIndex < keyCodes.size(); codeIndex++) {
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -07001069 std::vector<int32_t> scanCodes =
1070 device->keyMap.keyLayoutMap->findScanCodesForKey(keyCodes[codeIndex]);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001071
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -07001072 // check the possible scan codes identified by the layout map against the
1073 // map of codes actually emitted by the driver
Siarhei Vishniakou74007942022-06-13 13:57:47 -07001074 for (const int32_t scanCode : scanCodes) {
1075 if (device->keyBitmask.test(scanCode)) {
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -07001076 outFlags[codeIndex] = 1;
1077 break;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001078 }
1079 }
1080 }
1081 return true;
1082 }
1083 return false;
1084}
1085
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001086void EventHub::addKeyRemapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode) const {
1087 std::scoped_lock _l(mLock);
1088 Device* device = getDeviceLocked(deviceId);
1089 if (device == nullptr) {
1090 return;
1091 }
1092 const std::shared_ptr<KeyCharacterMap> kcm = device->getKeyCharacterMap();
1093 if (kcm) {
1094 kcm->addKeyRemapping(fromKeyCode, toKeyCode);
1095 }
1096}
1097
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001098status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
1099 int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
Chris Ye87143712020-11-10 05:05:58 +00001100 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001101 Device* device = getDeviceLocked(deviceId);
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001102 status_t status = NAME_NOT_FOUND;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001103
Chris Ye66fbac32020-07-06 20:36:43 -07001104 if (device != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001105 // Check the key character map first.
Chris Ye3a1e4462020-08-12 10:13:15 -07001106 const std::shared_ptr<KeyCharacterMap> kcm = device->getKeyCharacterMap();
1107 if (kcm) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001108 if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {
1109 *outFlags = 0;
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001110 status = NO_ERROR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001111 }
1112 }
1113
1114 // Check the key layout next.
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001115 if (status != NO_ERROR && device->keyMap.haveKeyLayout()) {
Siarhei Vishniakou592bac22018-11-08 19:42:38 -08001116 if (!device->keyMap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags)) {
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001117 status = NO_ERROR;
1118 }
1119 }
1120
1121 if (status == NO_ERROR) {
Chris Ye3a1e4462020-08-12 10:13:15 -07001122 if (kcm) {
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +00001123 // Remap keys based on user-defined key remappings and key behavior defined in the
1124 // corresponding kcm file
1125 *outKeycode = kcm->applyKeyRemapping(*outKeycode);
1126
1127 // Remap keys based on Key behavior defined in KCM file
1128 std::tie(*outKeycode, *outMetaState) =
1129 kcm->applyKeyBehavior(*outKeycode, metaState);
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001130 } else {
1131 *outMetaState = metaState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001132 }
1133 }
1134 }
1135
Dmitry Torokhov0faaa0b2015-09-24 13:13:55 -07001136 if (status != NO_ERROR) {
1137 *outKeycode = 0;
1138 *outFlags = 0;
1139 *outMetaState = metaState;
1140 }
1141
1142 return status;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001143}
1144
1145status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const {
Chris Ye87143712020-11-10 05:05:58 +00001146 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001147 Device* device = getDeviceLocked(deviceId);
1148
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -07001149 if (device == nullptr || !device->keyMap.haveKeyLayout()) {
1150 return NAME_NOT_FOUND;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001151 }
Siarhei Vishniakouef1564c2022-05-18 09:45:54 -07001152 std::optional<AxisInfo> info = device->keyMap.keyLayoutMap->mapAxis(scanCode);
1153 if (!info.has_value()) {
1154 return NAME_NOT_FOUND;
1155 }
1156 *outAxisInfo = *info;
1157 return NO_ERROR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001158}
1159
Chris Yef59a2f42020-10-16 12:55:26 -07001160base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId,
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001161 int32_t absCode) const {
Chris Yef59a2f42020-10-16 12:55:26 -07001162 std::scoped_lock _l(mLock);
1163 Device* device = getDeviceLocked(deviceId);
1164
1165 if (device != nullptr && device->keyMap.haveKeyLayout()) {
1166 return device->keyMap.keyLayoutMap->mapSensor(absCode);
1167 }
1168 return Errorf("Device not found or device has no key layout.");
1169}
1170
Chris Yee2b1e5c2021-03-10 22:45:12 -08001171// Gets the battery info map from battery ID to RawBatteryInfo of the miscellaneous device
1172// associated with the device ID. Returns an empty map if no miscellaneous device found.
1173const std::unordered_map<int32_t, RawBatteryInfo>& EventHub::getBatteryInfoLocked(
1174 int32_t deviceId) const {
1175 static const std::unordered_map<int32_t, RawBatteryInfo> EMPTY_BATTERY_INFO = {};
1176 Device* device = getDeviceLocked(deviceId);
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001177 if (device == nullptr || !device->associatedDevice) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001178 return EMPTY_BATTERY_INFO;
1179 }
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001180 return device->associatedDevice->batteryInfos;
Chris Yee2b1e5c2021-03-10 22:45:12 -08001181}
1182
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001183std::vector<int32_t> EventHub::getRawBatteryIds(int32_t deviceId) const {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001184 std::scoped_lock _l(mLock);
1185 std::vector<int32_t> batteryIds;
1186
Prabir Pradhan51894782022-08-23 16:29:10 +00001187 for (const auto& [id, info] : getBatteryInfoLocked(deviceId)) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001188 batteryIds.push_back(id);
1189 }
1190
1191 return batteryIds;
1192}
1193
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001194std::optional<RawBatteryInfo> EventHub::getRawBatteryInfo(int32_t deviceId,
1195 int32_t batteryId) const {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001196 std::scoped_lock _l(mLock);
1197
1198 const auto infos = getBatteryInfoLocked(deviceId);
1199
1200 auto it = infos.find(batteryId);
1201 if (it != infos.end()) {
1202 return it->second;
1203 }
1204
1205 return std::nullopt;
1206}
1207
1208// Gets the light info map from light ID to RawLightInfo of the miscellaneous device associated
Prabir Pradhan51894782022-08-23 16:29:10 +00001209// with the device ID. Returns an empty map if no miscellaneous device found.
Chris Yee2b1e5c2021-03-10 22:45:12 -08001210const std::unordered_map<int32_t, RawLightInfo>& EventHub::getLightInfoLocked(
1211 int32_t deviceId) const {
1212 static const std::unordered_map<int32_t, RawLightInfo> EMPTY_LIGHT_INFO = {};
1213 Device* device = getDeviceLocked(deviceId);
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001214 if (device == nullptr || !device->associatedDevice) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001215 return EMPTY_LIGHT_INFO;
1216 }
Chris Ye1dd2e5c2021-04-04 23:12:41 -07001217 return device->associatedDevice->lightInfos;
Chris Yee2b1e5c2021-03-10 22:45:12 -08001218}
1219
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001220std::vector<int32_t> EventHub::getRawLightIds(int32_t deviceId) const {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001221 std::scoped_lock _l(mLock);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001222 std::vector<int32_t> lightIds;
1223
Prabir Pradhan51894782022-08-23 16:29:10 +00001224 for (const auto& [id, info] : getLightInfoLocked(deviceId)) {
Chris Yee2b1e5c2021-03-10 22:45:12 -08001225 lightIds.push_back(id);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001226 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001227
Chris Ye3fdbfef2021-01-06 18:45:18 -08001228 return lightIds;
1229}
1230
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001231std::optional<RawLightInfo> EventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) const {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001232 std::scoped_lock _l(mLock);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001233
Chris Yee2b1e5c2021-03-10 22:45:12 -08001234 const auto infos = getLightInfoLocked(deviceId);
1235
1236 auto it = infos.find(lightId);
1237 if (it != infos.end()) {
1238 return it->second;
Chris Ye3fdbfef2021-01-06 18:45:18 -08001239 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001240
Chris Ye3fdbfef2021-01-06 18:45:18 -08001241 return std::nullopt;
1242}
1243
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001244std::optional<int32_t> EventHub::getLightBrightness(int32_t deviceId, int32_t lightId) const {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001245 std::scoped_lock _l(mLock);
1246
Chris Yee2b1e5c2021-03-10 22:45:12 -08001247 const auto infos = getLightInfoLocked(deviceId);
1248 auto it = infos.find(lightId);
1249 if (it == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001250 return std::nullopt;
1251 }
1252 std::string buffer;
1253 if (!base::ReadFileToString(it->second.path / LIGHT_NODES.at(InputLightClass::BRIGHTNESS),
1254 &buffer)) {
1255 return std::nullopt;
1256 }
1257 return std::stoi(buffer);
1258}
1259
1260std::optional<std::unordered_map<LightColor, int32_t>> EventHub::getLightIntensities(
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001261 int32_t deviceId, int32_t lightId) const {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001262 std::scoped_lock _l(mLock);
1263
Chris Yee2b1e5c2021-03-10 22:45:12 -08001264 const auto infos = getLightInfoLocked(deviceId);
1265 auto lightIt = infos.find(lightId);
1266 if (lightIt == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001267 return std::nullopt;
1268 }
1269
1270 auto ret =
1271 getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX));
1272
1273 if (!ret.has_value()) {
1274 return std::nullopt;
1275 }
1276 std::array<LightColor, COLOR_NUM> colors = ret.value();
1277
1278 std::string intensityStr;
1279 if (!base::ReadFileToString(lightIt->second.path /
1280 LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY),
1281 &intensityStr)) {
1282 return std::nullopt;
1283 }
1284
1285 // Intensity node outputs 3 color values
1286 std::regex intensityPattern("([0-9]+)\\s([0-9]+)\\s([0-9]+)[\\n]");
1287 std::smatch results;
1288
1289 if (!std::regex_match(intensityStr, results, intensityPattern)) {
1290 return std::nullopt;
1291 }
1292 std::unordered_map<LightColor, int32_t> intensities;
1293 for (size_t i = 1; i < results.size(); i++) {
1294 int value = std::stoi(results[i].str());
1295 intensities.emplace(colors[i - 1], value);
1296 }
1297 return intensities;
1298}
1299
1300void EventHub::setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) {
1301 std::scoped_lock _l(mLock);
1302
Chris Yee2b1e5c2021-03-10 22:45:12 -08001303 const auto infos = getLightInfoLocked(deviceId);
1304 auto lightIt = infos.find(lightId);
1305 if (lightIt == infos.end()) {
1306 ALOGE("%s lightId %d not found ", __func__, lightId);
Chris Ye3fdbfef2021-01-06 18:45:18 -08001307 return;
1308 }
1309
1310 if (!base::WriteStringToFile(std::to_string(brightness),
1311 lightIt->second.path /
1312 LIGHT_NODES.at(InputLightClass::BRIGHTNESS))) {
1313 ALOGE("Can not write to file, error: %s", strerror(errno));
1314 }
1315}
1316
1317void EventHub::setLightIntensities(int32_t deviceId, int32_t lightId,
1318 std::unordered_map<LightColor, int32_t> intensities) {
1319 std::scoped_lock _l(mLock);
1320
Chris Yee2b1e5c2021-03-10 22:45:12 -08001321 const auto infos = getLightInfoLocked(deviceId);
1322 auto lightIt = infos.find(lightId);
1323 if (lightIt == infos.end()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08001324 ALOGE("Light Id %d does not exist.", lightId);
1325 return;
1326 }
1327
1328 auto ret =
1329 getColorIndexArray(lightIt->second.path / LIGHT_NODES.at(InputLightClass::MULTI_INDEX));
1330
1331 if (!ret.has_value()) {
1332 return;
1333 }
1334 std::array<LightColor, COLOR_NUM> colors = ret.value();
1335
1336 std::string rgbStr;
1337 for (size_t i = 0; i < COLOR_NUM; i++) {
1338 auto it = intensities.find(colors[i]);
1339 if (it != intensities.end()) {
1340 rgbStr += std::to_string(it->second);
1341 // Insert space between colors
1342 if (i < COLOR_NUM - 1) {
1343 rgbStr += " ";
1344 }
1345 }
1346 }
1347 // Append new line
1348 rgbStr += "\n";
1349
1350 if (!base::WriteStringToFile(rgbStr,
1351 lightIt->second.path /
1352 LIGHT_NODES.at(InputLightClass::MULTI_INTENSITY))) {
1353 ALOGE("Can not write to file, error: %s", strerror(errno));
1354 }
1355}
1356
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +00001357std::optional<RawLayoutInfo> EventHub::getRawLayoutInfo(int32_t deviceId) const {
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +00001358 std::scoped_lock _l(mLock);
1359 Device* device = getDeviceLocked(deviceId);
1360 if (device == nullptr || !device->associatedDevice) {
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +00001361 return std::nullopt;
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +00001362 }
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +00001363 return device->associatedDevice->layoutInfo;
Vaibhav Devmuraridd82b8e2022-08-16 15:34:01 +00001364}
1365
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001366void EventHub::setExcludedDevices(const std::vector<std::string>& devices) {
Chris Ye87143712020-11-10 05:05:58 +00001367 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001368
1369 mExcludedDevices = devices;
1370}
1371
1372bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
Chris Ye87143712020-11-10 05:05:58 +00001373 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001374 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001375 if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {
1376 return device->keyBitmask.test(scanCode);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001377 }
1378 return false;
1379}
1380
Arthur Hungcb40a002021-08-03 14:31:01 +00001381bool EventHub::hasKeyCode(int32_t deviceId, int32_t keyCode) const {
1382 std::scoped_lock _l(mLock);
1383 Device* device = getDeviceLocked(deviceId);
1384 if (device != nullptr) {
1385 return device->hasKeycodeLocked(keyCode);
1386 }
1387 return false;
1388}
1389
Michael Wrightd02c5b62014-02-10 15:10:22 -08001390bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
Chris Ye87143712020-11-10 05:05:58 +00001391 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001392 Device* device = getDeviceLocked(deviceId);
1393 int32_t sc;
Chris Ye989bb932020-07-04 16:18:59 -07001394 if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) {
Chris Ye66fbac32020-07-06 20:36:43 -07001395 return device->ledBitmask.test(sc);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001396 }
1397 return false;
1398}
1399
1400void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) {
Chris Ye87143712020-11-10 05:05:58 +00001401 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001402 Device* device = getDeviceLocked(deviceId);
Chris Ye989bb932020-07-04 16:18:59 -07001403 if (device != nullptr && device->hasValidFd()) {
1404 device->setLedStateLocked(led, on);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001405 }
1406}
1407
1408void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001409 std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001410 outVirtualKeys.clear();
1411
Chris Ye87143712020-11-10 05:05:58 +00001412 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001413 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001414 if (device != nullptr && device->virtualKeyMap) {
Arthur Hung7c3ae9c2019-03-11 11:23:03 +08001415 const std::vector<VirtualKeyDefinition> virtualKeys =
1416 device->virtualKeyMap->getVirtualKeys();
1417 outVirtualKeys.insert(outVirtualKeys.end(), virtualKeys.begin(), virtualKeys.end());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001418 }
1419}
1420
Chris Ye3a1e4462020-08-12 10:13:15 -07001421const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +00001422 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001423 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001424 if (device != nullptr) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001425 return device->getKeyCharacterMap();
1426 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001427 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001428}
1429
Vaibhav Devmurari23e8ae92022-12-29 12:07:56 +00001430// If provided map is null, it will reset key character map to default KCM.
Chris Ye3a1e4462020-08-12 10:13:15 -07001431bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId, std::shared_ptr<KeyCharacterMap> map) {
Chris Ye87143712020-11-10 05:05:58 +00001432 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001433 Device* device = getDeviceLocked(deviceId);
Vaibhav Devmurari23e8ae92022-12-29 12:07:56 +00001434 if (device == nullptr || device->keyMap.keyCharacterMap == nullptr) {
Philip Junker90bc9492021-12-10 18:39:42 +01001435 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001436 }
Vaibhav Devmurari23e8ae92022-12-29 12:07:56 +00001437 if (map == nullptr) {
1438 device->keyMap.keyCharacterMap->clearLayoutOverlay();
1439 return true;
1440 }
Philip Junker90bc9492021-12-10 18:39:42 +01001441 device->keyMap.keyCharacterMap->combine(*map);
1442 return true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001443}
1444
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001445static std::string generateDescriptor(InputDeviceIdentifier& identifier) {
1446 std::string rawDescriptor;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001447 rawDescriptor += StringPrintf(":%04x:%04x:", identifier.vendor, identifier.product);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001448 // TODO add handling for USB devices to not uniqueify kbs that show up twice
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001449 if (!identifier.uniqueId.empty()) {
1450 rawDescriptor += "uniqueId:";
1451 rawDescriptor += identifier.uniqueId;
Josh Bartel938632f2022-07-19 15:34:22 -05001452 }
1453 if (identifier.nonce != 0) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001454 rawDescriptor += StringPrintf("nonce:%04x", identifier.nonce);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001455 }
1456
1457 if (identifier.vendor == 0 && identifier.product == 0) {
1458 // If we don't know the vendor and product id, then the device is probably
1459 // built-in so we need to rely on other information to uniquely identify
1460 // the input device. Usually we try to avoid relying on the device name or
1461 // location but for built-in input device, they are unlikely to ever change.
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001462 if (!identifier.name.empty()) {
1463 rawDescriptor += "name:";
1464 rawDescriptor += identifier.name;
1465 } else if (!identifier.location.empty()) {
1466 rawDescriptor += "location:";
1467 rawDescriptor += identifier.location;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001468 }
1469 }
1470 identifier.descriptor = sha1(rawDescriptor);
1471 return rawDescriptor;
1472}
1473
1474void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) {
1475 // Compute a device descriptor that uniquely identifies the device.
1476 // The descriptor is assumed to be a stable identifier. Its value should not
1477 // change between reboots, reconnections, firmware updates or new releases
1478 // of Android. In practice we sometimes get devices that cannot be uniquely
1479 // identified. In this case we enforce uniqueness between connected devices.
1480 // Ideally, we also want the descriptor to be short and relatively opaque.
Josh Bartel938632f2022-07-19 15:34:22 -05001481 // Note that we explicitly do not use the path or location for external devices
1482 // as their path or location will change as they are plugged/unplugged or moved
1483 // to different ports. We do fallback to using name and location in the case of
1484 // internal devices which are detected by the vendor and product being 0 in
1485 // generateDescriptor. If two identical descriptors are detected we will fallback
1486 // to using a 'nonce' and incrementing it until the new descriptor no longer has
1487 // a match with any existing descriptors.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001488
1489 identifier.nonce = 0;
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001490 std::string rawDescriptor = generateDescriptor(identifier);
Josh Bartel938632f2022-07-19 15:34:22 -05001491 // Enforce that the generated descriptor is unique.
1492 while (hasDeviceWithDescriptorLocked(identifier.descriptor)) {
1493 identifier.nonce++;
1494 rawDescriptor = generateDescriptor(identifier);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001495 }
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001496 ALOGV("Created descriptor: raw=%s, cooked=%s", rawDescriptor.c_str(),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001497 identifier.descriptor.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001498}
1499
Prabir Pradhancb42b472022-08-23 16:01:19 +00001500std::shared_ptr<const EventHub::AssociatedDevice> EventHub::obtainAssociatedDeviceLocked(
1501 const std::filesystem::path& devicePath) const {
1502 const std::optional<std::filesystem::path> sysfsRootPathOpt =
1503 getSysfsRootPath(devicePath.c_str());
1504 if (!sysfsRootPathOpt) {
1505 return nullptr;
1506 }
1507
1508 const auto& path = *sysfsRootPathOpt;
Prabir Pradhancb42b472022-08-23 16:01:19 +00001509
Prabir Pradhanedeec3b2022-08-26 22:33:55 +00001510 std::shared_ptr<const AssociatedDevice> associatedDevice = std::make_shared<AssociatedDevice>(
Prabir Pradhancb42b472022-08-23 16:01:19 +00001511 AssociatedDevice{.sysfsRootPath = path,
1512 .batteryInfos = readBatteryConfiguration(path),
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +00001513 .lightInfos = readLightsConfiguration(path),
1514 .layoutInfo = readLayoutConfiguration(path)});
Prabir Pradhanedeec3b2022-08-26 22:33:55 +00001515
1516 bool associatedDeviceChanged = false;
1517 for (const auto& [id, dev] : mDevices) {
1518 if (dev->associatedDevice && dev->associatedDevice->sysfsRootPath == path) {
1519 if (*associatedDevice != *dev->associatedDevice) {
1520 associatedDeviceChanged = true;
1521 dev->associatedDevice = associatedDevice;
1522 }
1523 associatedDevice = dev->associatedDevice;
1524 }
1525 }
1526 ALOGI_IF(associatedDeviceChanged,
1527 "The AssociatedDevice changed for path '%s'. Using new AssociatedDevice: %s",
1528 path.c_str(), associatedDevice->dump().c_str());
1529
1530 return associatedDevice;
Prabir Pradhancb42b472022-08-23 16:01:19 +00001531}
1532
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001533void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) {
Chris Ye87143712020-11-10 05:05:58 +00001534 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001535 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001536 if (device != nullptr && device->hasValidFd()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001537 ff_effect effect;
1538 memset(&effect, 0, sizeof(effect));
1539 effect.type = FF_RUMBLE;
1540 effect.id = device->ffEffectId;
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001541 // evdev FF_RUMBLE effect only supports two channels of vibration.
Chris Ye6393a262020-08-04 19:41:36 -07001542 effect.u.rumble.strong_magnitude = element.getMagnitude(FF_STRONG_MAGNITUDE_CHANNEL_IDX);
1543 effect.u.rumble.weak_magnitude = element.getMagnitude(FF_WEAK_MAGNITUDE_CHANNEL_IDX);
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +00001544 effect.replay.length = element.duration.count();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001545 effect.replay.delay = 0;
1546 if (ioctl(device->fd, EVIOCSFF, &effect)) {
1547 ALOGW("Could not upload force feedback effect to device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001548 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001549 return;
1550 }
1551 device->ffEffectId = effect.id;
1552
1553 struct input_event ev;
Colin Cross5b799302022-10-18 21:52:41 -07001554 ev.input_event_sec = 0;
1555 ev.input_event_usec = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001556 ev.type = EV_FF;
1557 ev.code = device->ffEffectId;
1558 ev.value = 1;
1559 if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
1560 ALOGW("Could not start force feedback effect on device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001561 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001562 return;
1563 }
1564 device->ffEffectPlaying = true;
1565 }
1566}
1567
1568void EventHub::cancelVibrate(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00001569 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001570 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07001571 if (device != nullptr && device->hasValidFd()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001572 if (device->ffEffectPlaying) {
1573 device->ffEffectPlaying = false;
1574
1575 struct input_event ev;
Colin Cross5b799302022-10-18 21:52:41 -07001576 ev.input_event_sec = 0;
1577 ev.input_event_usec = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001578 ev.type = EV_FF;
1579 ev.code = device->ffEffectId;
1580 ev.value = 0;
1581 if (write(device->fd, &ev, sizeof(ev)) != sizeof(ev)) {
1582 ALOGW("Could not stop force feedback effect on device %s due to error %d.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001583 device->identifier.name.c_str(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001584 return;
1585 }
1586 }
1587 }
1588}
1589
Prabir Pradhanae4ff282022-08-23 16:21:39 +00001590std::vector<int32_t> EventHub::getVibratorIds(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +00001591 std::scoped_lock _l(mLock);
1592 std::vector<int32_t> vibrators;
1593 Device* device = getDeviceLocked(deviceId);
1594 if (device != nullptr && device->hasValidFd() &&
1595 device->classes.test(InputDeviceClass::VIBRATOR)) {
1596 vibrators.push_back(FF_STRONG_MAGNITUDE_CHANNEL_IDX);
1597 vibrators.push_back(FF_WEAK_MAGNITUDE_CHANNEL_IDX);
1598 }
1599 return vibrators;
1600}
1601
Josh Bartel938632f2022-07-19 15:34:22 -05001602/**
1603 * Checks both mDevices and mOpeningDevices for a device with the descriptor passed.
1604 */
1605bool EventHub::hasDeviceWithDescriptorLocked(const std::string& descriptor) const {
1606 for (const auto& device : mOpeningDevices) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01001607 if (descriptor == device->identifier.descriptor) {
Josh Bartel938632f2022-07-19 15:34:22 -05001608 return true;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001609 }
1610 }
Josh Bartel938632f2022-07-19 15:34:22 -05001611
1612 for (const auto& [id, device] : mDevices) {
1613 if (descriptor == device->identifier.descriptor) {
1614 return true;
1615 }
1616 }
1617 return false;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001618}
1619
1620EventHub::Device* EventHub::getDeviceLocked(int32_t deviceId) const {
Prabir Pradhancae4b3a2019-02-05 18:51:32 -08001621 if (deviceId == ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001622 deviceId = mBuiltInKeyboardId;
1623 }
Chris Ye989bb932020-07-04 16:18:59 -07001624 const auto& it = mDevices.find(deviceId);
1625 return it != mDevices.end() ? it->second.get() : nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001626}
1627
Chris Ye8594e192020-07-14 10:34:06 -07001628EventHub::Device* EventHub::getDeviceByPathLocked(const std::string& devicePath) const {
Chris Ye989bb932020-07-04 16:18:59 -07001629 for (const auto& [id, device] : mDevices) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001630 if (device->path == devicePath) {
Chris Ye989bb932020-07-04 16:18:59 -07001631 return device.get();
Michael Wrightd02c5b62014-02-10 15:10:22 -08001632 }
1633 }
Yi Kong9b14ac62018-07-17 13:48:38 -07001634 return nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001635}
1636
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001637/**
1638 * The file descriptor could be either input device, or a video device (associated with a
1639 * specific input device). Check both cases here, and return the device that this event
1640 * belongs to. Caller can compare the fd's once more to determine event type.
1641 * Looks through all input devices, and only attached video devices. Unattached video
1642 * devices are ignored.
1643 */
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001644EventHub::Device* EventHub::getDeviceByFdLocked(int fd) const {
Chris Ye989bb932020-07-04 16:18:59 -07001645 for (const auto& [id, device] : mDevices) {
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001646 if (device->fd == fd) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001647 // This is an input device event
Chris Ye989bb932020-07-04 16:18:59 -07001648 return device.get();
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001649 }
1650 if (device->videoDevice && device->videoDevice->getFd() == fd) {
1651 // This is a video device event
Chris Ye989bb932020-07-04 16:18:59 -07001652 return device.get();
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001653 }
1654 }
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001655 // We do not check mUnattachedVideoDevices here because they should not participate in epoll,
1656 // and therefore should never be looked up by fd.
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001657 return nullptr;
1658}
1659
Chris Yee2b1e5c2021-03-10 22:45:12 -08001660std::optional<int32_t> EventHub::getBatteryCapacity(int32_t deviceId, int32_t batteryId) const {
Andy Chenf9f1a022022-08-29 20:07:10 -04001661 std::filesystem::path batteryPath;
1662 {
1663 // Do not read the sysfs node to get the battery state while holding
1664 // the EventHub lock. For some peripheral devices, reading battery state
1665 // can be broken and take 5+ seconds. Holding the lock in this case would
1666 // block all other event processing during this time. For now, we assume this
1667 // call never happens on the InputReader thread and read the sysfs node outside
1668 // the lock to prevent event processing from being blocked by this call.
1669 std::scoped_lock _l(mLock);
Kim Low03ea0352020-11-06 12:45:07 -08001670
Prabir Pradhane287ecd2022-09-07 21:18:05 +00001671 const auto& infos = getBatteryInfoLocked(deviceId);
Andy Chenf9f1a022022-08-29 20:07:10 -04001672 auto it = infos.find(batteryId);
1673 if (it == infos.end()) {
1674 return std::nullopt;
1675 }
1676 batteryPath = it->second.path;
1677 } // release lock
1678
Chris Yee2b1e5c2021-03-10 22:45:12 -08001679 std::string buffer;
Kim Low03ea0352020-11-06 12:45:07 -08001680
1681 // Some devices report battery capacity as an integer through the "capacity" file
Andy Chenf9f1a022022-08-29 20:07:10 -04001682 if (base::ReadFileToString(batteryPath / BATTERY_NODES.at(InputBatteryClass::CAPACITY),
Chris Yee2b1e5c2021-03-10 22:45:12 -08001683 &buffer)) {
Chris Yed1936772021-02-22 10:30:40 -08001684 return std::stoi(base::Trim(buffer));
Kim Low03ea0352020-11-06 12:45:07 -08001685 }
1686
1687 // Other devices report capacity as an enum value POWER_SUPPLY_CAPACITY_LEVEL_XXX
1688 // These values are taken from kernel source code include/linux/power_supply.h
Andy Chenf9f1a022022-08-29 20:07:10 -04001689 if (base::ReadFileToString(batteryPath / BATTERY_NODES.at(InputBatteryClass::CAPACITY_LEVEL),
Chris Yee2b1e5c2021-03-10 22:45:12 -08001690 &buffer)) {
Chris Yed1936772021-02-22 10:30:40 -08001691 // Remove any white space such as trailing new line
Chris Yee2b1e5c2021-03-10 22:45:12 -08001692 const auto levelIt = BATTERY_LEVEL.find(base::Trim(buffer));
1693 if (levelIt != BATTERY_LEVEL.end()) {
1694 return levelIt->second;
Kim Low03ea0352020-11-06 12:45:07 -08001695 }
1696 }
Chris Yee2b1e5c2021-03-10 22:45:12 -08001697
Kim Low03ea0352020-11-06 12:45:07 -08001698 return std::nullopt;
1699}
1700
Chris Yee2b1e5c2021-03-10 22:45:12 -08001701std::optional<int32_t> EventHub::getBatteryStatus(int32_t deviceId, int32_t batteryId) const {
Andy Chenf9f1a022022-08-29 20:07:10 -04001702 std::filesystem::path batteryPath;
1703 {
1704 // Do not read the sysfs node to get the battery state while holding
1705 // the EventHub lock. For some peripheral devices, reading battery state
1706 // can be broken and take 5+ seconds. Holding the lock in this case would
1707 // block all other event processing during this time. For now, we assume this
1708 // call never happens on the InputReader thread and read the sysfs node outside
1709 // the lock to prevent event processing from being blocked by this call.
1710 std::scoped_lock _l(mLock);
1711
Prabir Pradhane287ecd2022-09-07 21:18:05 +00001712 const auto& infos = getBatteryInfoLocked(deviceId);
Andy Chenf9f1a022022-08-29 20:07:10 -04001713 auto it = infos.find(batteryId);
1714 if (it == infos.end()) {
1715 return std::nullopt;
1716 }
1717 batteryPath = it->second.path;
1718 } // release lock
1719
Chris Yee2b1e5c2021-03-10 22:45:12 -08001720 std::string buffer;
Kim Low03ea0352020-11-06 12:45:07 -08001721
Andy Chenf9f1a022022-08-29 20:07:10 -04001722 if (!base::ReadFileToString(batteryPath / BATTERY_NODES.at(InputBatteryClass::STATUS),
Chris Yee2b1e5c2021-03-10 22:45:12 -08001723 &buffer)) {
Kim Low03ea0352020-11-06 12:45:07 -08001724 ALOGE("Failed to read sysfs battery info: %s", strerror(errno));
1725 return std::nullopt;
1726 }
1727
Chris Yed1936772021-02-22 10:30:40 -08001728 // Remove white space like trailing new line
Chris Yee2b1e5c2021-03-10 22:45:12 -08001729 const auto statusIt = BATTERY_STATUS.find(base::Trim(buffer));
1730 if (statusIt != BATTERY_STATUS.end()) {
1731 return statusIt->second;
Kim Low03ea0352020-11-06 12:45:07 -08001732 }
1733
1734 return std::nullopt;
1735}
1736
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001737std::vector<RawEvent> EventHub::getEvents(int timeoutMillis) {
Chris Ye87143712020-11-10 05:05:58 +00001738 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001739
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001740 std::array<input_event, EVENT_BUFFER_SIZE> readBuffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001741
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001742 std::vector<RawEvent> events;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001743 bool awoken = false;
1744 for (;;) {
1745 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
1746
1747 // Reopen input devices if needed.
1748 if (mNeedToReopenDevices) {
1749 mNeedToReopenDevices = false;
1750
1751 ALOGI("Reopening all input devices due to a configuration change.");
1752
1753 closeAllDevicesLocked();
1754 mNeedToScanDevices = true;
1755 break; // return to the caller before we actually rescan
1756 }
1757
1758 // Report any devices that had last been added/removed.
Chris Ye989bb932020-07-04 16:18:59 -07001759 for (auto it = mClosingDevices.begin(); it != mClosingDevices.end();) {
1760 std::unique_ptr<Device> device = std::move(*it);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001761 ALOGV("Reporting device closed: id=%d, name=%s\n", device->id, device->path.c_str());
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001762 const int32_t deviceId = (device->id == mBuiltInKeyboardId)
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001763 ? ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID
1764 : device->id;
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001765 events.push_back({
1766 .when = now,
1767 .deviceId = deviceId,
1768 .type = DEVICE_REMOVED,
1769 });
Chris Ye989bb932020-07-04 16:18:59 -07001770 it = mClosingDevices.erase(it);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001771 mNeedToSendFinishedDeviceScan = true;
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001772 if (events.size() == EVENT_BUFFER_SIZE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001773 break;
1774 }
1775 }
1776
1777 if (mNeedToScanDevices) {
1778 mNeedToScanDevices = false;
1779 scanDevicesLocked();
1780 mNeedToSendFinishedDeviceScan = true;
1781 }
1782
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001783 while (!mOpeningDevices.empty()) {
1784 std::unique_ptr<Device> device = std::move(*mOpeningDevices.rbegin());
1785 mOpeningDevices.pop_back();
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001786 ALOGV("Reporting device opened: id=%d, name=%s\n", device->id, device->path.c_str());
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001787 const int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
1788 events.push_back({
1789 .when = now,
1790 .deviceId = deviceId,
1791 .type = DEVICE_ADDED,
1792 });
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001793
1794 // Try to find a matching video device by comparing device names
1795 for (auto it = mUnattachedVideoDevices.begin(); it != mUnattachedVideoDevices.end();
1796 it++) {
1797 std::unique_ptr<TouchVideoDevice>& videoDevice = *it;
Chris Yed3fef462021-03-07 17:10:08 -08001798 if (tryAddVideoDeviceLocked(*device, videoDevice)) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05001799 // videoDevice was transferred to 'device'
1800 it = mUnattachedVideoDevices.erase(it);
1801 break;
1802 }
1803 }
1804
1805 auto [dev_it, inserted] = mDevices.insert_or_assign(device->id, std::move(device));
1806 if (!inserted) {
Chris Ye989bb932020-07-04 16:18:59 -07001807 ALOGW("Device id %d exists, replaced.", device->id);
1808 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001809 mNeedToSendFinishedDeviceScan = true;
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001810 if (events.size() == EVENT_BUFFER_SIZE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001811 break;
1812 }
1813 }
1814
1815 if (mNeedToSendFinishedDeviceScan) {
1816 mNeedToSendFinishedDeviceScan = false;
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001817 events.push_back({
1818 .when = now,
1819 .type = FINISHED_DEVICE_SCAN,
1820 });
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001821 if (events.size() == EVENT_BUFFER_SIZE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001822 break;
1823 }
1824 }
1825
1826 // Grab the next input event.
1827 bool deviceChanged = false;
1828 while (mPendingEventIndex < mPendingEventCount) {
1829 const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001830 if (eventItem.data.fd == mINotifyFd) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001831 if (eventItem.events & EPOLLIN) {
1832 mPendingINotify = true;
1833 } else {
1834 ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
1835 }
1836 continue;
1837 }
1838
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001839 if (eventItem.data.fd == mWakeReadPipeFd) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001840 if (eventItem.events & EPOLLIN) {
1841 ALOGV("awoken after wake()");
1842 awoken = true;
Siarhei Vishniakoub4d960d2019-10-03 15:38:44 -05001843 char wakeReadBuffer[16];
Michael Wrightd02c5b62014-02-10 15:10:22 -08001844 ssize_t nRead;
1845 do {
Siarhei Vishniakoub4d960d2019-10-03 15:38:44 -05001846 nRead = read(mWakeReadPipeFd, wakeReadBuffer, sizeof(wakeReadBuffer));
1847 } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(wakeReadBuffer));
Michael Wrightd02c5b62014-02-10 15:10:22 -08001848 } else {
1849 ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001850 eventItem.events);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001851 }
1852 continue;
1853 }
1854
Siarhei Vishniakou4bc561c2018-11-02 17:41:58 -07001855 Device* device = getDeviceByFdLocked(eventItem.data.fd);
Chris Ye989bb932020-07-04 16:18:59 -07001856 if (device == nullptr) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001857 ALOGE("Received unexpected epoll event 0x%08x for unknown fd %d.", eventItem.events,
1858 eventItem.data.fd);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001859 ALOG_ASSERT(!DEBUG);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001860 continue;
1861 }
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001862 if (device->videoDevice && eventItem.data.fd == device->videoDevice->getFd()) {
1863 if (eventItem.events & EPOLLIN) {
1864 size_t numFrames = device->videoDevice->readAndQueueFrames();
1865 if (numFrames == 0) {
1866 ALOGE("Received epoll event for video device %s, but could not read frame",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001867 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001868 }
1869 } else if (eventItem.events & EPOLLHUP) {
1870 // TODO(b/121395353) - consider adding EPOLLRDHUP
1871 ALOGI("Removing video device %s due to epoll hang-up event.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001872 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001873 unregisterVideoDeviceFromEpollLocked(*device->videoDevice);
1874 device->videoDevice = nullptr;
1875 } else {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001876 ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events,
1877 device->videoDevice->getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07001878 ALOG_ASSERT(!DEBUG);
1879 }
1880 continue;
1881 }
1882 // This must be an input event
Michael Wrightd02c5b62014-02-10 15:10:22 -08001883 if (eventItem.events & EPOLLIN) {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001884 int32_t readSize =
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001885 read(device->fd, readBuffer.data(),
1886 sizeof(decltype(readBuffer)::value_type) * readBuffer.size());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001887 if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
1888 // Device was removed before INotify noticed.
Mark Salyzyn5aa26b22014-06-10 13:07:44 -07001889 ALOGW("could not get event, removed? (fd: %d size: %" PRId32
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001890 " capacity: %zu errno: %d)\n",
1891 device->fd, readSize, readBuffer.size(), errno);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001892 deviceChanged = true;
Chris Ye989bb932020-07-04 16:18:59 -07001893 closeDeviceLocked(*device);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001894 } else if (readSize < 0) {
1895 if (errno != EAGAIN && errno != EINTR) {
1896 ALOGW("could not get event (errno=%d)", errno);
1897 }
1898 } else if ((readSize % sizeof(struct input_event)) != 0) {
1899 ALOGE("could not get event (wrong size: %d)", readSize);
1900 } else {
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001901 const int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001902
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001903 const size_t count = size_t(readSize) / sizeof(struct input_event);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001904 for (size_t i = 0; i < count; i++) {
1905 struct input_event& iev = readBuffer[i];
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001906 events.push_back({
1907 .when = processEventTimestamp(iev),
1908 .readTime = systemTime(SYSTEM_TIME_MONOTONIC),
1909 .deviceId = deviceId,
1910 .type = iev.type,
1911 .code = iev.code,
1912 .value = iev.value,
1913 });
Michael Wrightd02c5b62014-02-10 15:10:22 -08001914 }
Siarhei Vishniakou45fd9042022-09-27 13:26:20 -07001915 if (events.size() >= EVENT_BUFFER_SIZE) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001916 // The result buffer is full. Reset the pending event index
1917 // so we will try to read the device again on the next iteration.
1918 mPendingEventIndex -= 1;
1919 break;
1920 }
1921 }
1922 } else if (eventItem.events & EPOLLHUP) {
1923 ALOGI("Removing device %s due to epoll hang-up event.",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001924 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001925 deviceChanged = true;
Chris Ye989bb932020-07-04 16:18:59 -07001926 closeDeviceLocked(*device);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001927 } else {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07001928 ALOGW("Received unexpected epoll event 0x%08x for device %s.", eventItem.events,
1929 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08001930 }
1931 }
1932
1933 // readNotify() will modify the list of devices so this must be done after
1934 // processing all other events to ensure that we read all remaining events
1935 // before closing the devices.
1936 if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
1937 mPendingINotify = false;
Prabir Pradhan952e65b2022-06-23 17:49:55 +00001938 const auto res = readNotifyLocked();
1939 if (!res.ok()) {
1940 ALOGW("Failed to read from inotify: %s", res.error().message().c_str());
1941 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08001942 deviceChanged = true;
1943 }
1944
1945 // Report added or removed devices immediately.
1946 if (deviceChanged) {
1947 continue;
1948 }
1949
1950 // Return now if we have collected any events or if we were explicitly awoken.
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001951 if (!events.empty() || awoken) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08001952 break;
1953 }
1954
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001955 // Poll for events.
1956 // When a device driver has pending (unread) events, it acquires
1957 // a kernel wake lock. Once the last pending event has been read, the device
1958 // driver will release the kernel wake lock, but the epoll will hold the wakelock,
1959 // since we are using EPOLLWAKEUP. The wakelock is released by the epoll when epoll_wait
1960 // is called again for the same fd that produced the event.
1961 // Thus the system can only sleep if there are no events pending or
1962 // currently being processed.
Michael Wrightd02c5b62014-02-10 15:10:22 -08001963 //
1964 // The timeout is advisory only. If the device is asleep, it will not wake just to
1965 // service the timeout.
1966 mPendingEventIndex = 0;
1967
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001968 mLock.unlock(); // release lock before poll
Michael Wrightd02c5b62014-02-10 15:10:22 -08001969
1970 int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
1971
Siarhei Vishniakou4b5a87f2019-09-24 13:03:58 +01001972 mLock.lock(); // reacquire lock after poll
Michael Wrightd02c5b62014-02-10 15:10:22 -08001973
1974 if (pollResult == 0) {
1975 // Timed out.
1976 mPendingEventCount = 0;
1977 break;
1978 }
1979
1980 if (pollResult < 0) {
1981 // An error occurred.
1982 mPendingEventCount = 0;
1983
1984 // Sleep after errors to avoid locking up the system.
1985 // Hopefully the error is transient.
1986 if (errno != EINTR) {
1987 ALOGW("poll failed (errno=%d)\n", errno);
1988 usleep(100000);
1989 }
1990 } else {
1991 // Some events occurred.
1992 mPendingEventCount = size_t(pollResult);
1993 }
1994 }
1995
1996 // All done, return the number of events we read.
Siarhei Vishniakou7b3ea0b2022-09-16 14:23:20 -07001997 return events;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001998}
1999
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08002000std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002001 std::scoped_lock _l(mLock);
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08002002
2003 Device* device = getDeviceLocked(deviceId);
Chris Ye66fbac32020-07-06 20:36:43 -07002004 if (device == nullptr || !device->videoDevice) {
Siarhei Vishniakouadd89292018-12-13 19:23:36 -08002005 return {};
2006 }
2007 return device->videoDevice->consumeFrames();
2008}
2009
Michael Wrightd02c5b62014-02-10 15:10:22 -08002010void EventHub::wake() {
2011 ALOGV("wake() called");
2012
2013 ssize_t nWrite;
2014 do {
2015 nWrite = write(mWakeWritePipeFd, "W", 1);
2016 } while (nWrite == -1 && errno == EINTR);
2017
2018 if (nWrite != 1 && errno != EAGAIN) {
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002019 ALOGW("Could not write wake signal: %s", strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002020 }
2021}
2022
2023void EventHub::scanDevicesLocked() {
Usama Arifb27c8e62021-06-03 16:44:09 +01002024 status_t result;
2025 std::error_code errorCode;
2026
2027 if (std::filesystem::exists(DEVICE_INPUT_PATH, errorCode)) {
2028 result = scanDirLocked(DEVICE_INPUT_PATH);
2029 if (result < 0) {
2030 ALOGE("scan dir failed for %s", DEVICE_INPUT_PATH);
2031 }
2032 } else {
2033 if (errorCode) {
2034 ALOGW("Could not run filesystem::exists() due to error %d : %s.", errorCode.value(),
2035 errorCode.message().c_str());
2036 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002037 }
Philip Quinn39b81682019-01-09 22:20:39 -08002038 if (isV4lScanningEnabled()) {
Usama Arifb27c8e62021-06-03 16:44:09 +01002039 result = scanVideoDirLocked(DEVICE_PATH);
Philip Quinn39b81682019-01-09 22:20:39 -08002040 if (result != OK) {
Usama Arifb27c8e62021-06-03 16:44:09 +01002041 ALOGE("scan video dir failed for %s", DEVICE_PATH);
Philip Quinn39b81682019-01-09 22:20:39 -08002042 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002043 }
Chris Ye989bb932020-07-04 16:18:59 -07002044 if (mDevices.find(ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID) == mDevices.end()) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002045 createVirtualKeyboardLocked();
2046 }
2047}
2048
2049// ----------------------------------------------------------------------------
2050
Michael Wrightd02c5b62014-02-10 15:10:22 -08002051static const int32_t GAMEPAD_KEYCODES[] = {
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002052 AKEYCODE_BUTTON_A, AKEYCODE_BUTTON_B, AKEYCODE_BUTTON_C, //
2053 AKEYCODE_BUTTON_X, AKEYCODE_BUTTON_Y, AKEYCODE_BUTTON_Z, //
2054 AKEYCODE_BUTTON_L1, AKEYCODE_BUTTON_R1, //
2055 AKEYCODE_BUTTON_L2, AKEYCODE_BUTTON_R2, //
2056 AKEYCODE_BUTTON_THUMBL, AKEYCODE_BUTTON_THUMBR, //
2057 AKEYCODE_BUTTON_START, AKEYCODE_BUTTON_SELECT, AKEYCODE_BUTTON_MODE, //
Michael Wrightd02c5b62014-02-10 15:10:22 -08002058};
2059
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002060status_t EventHub::registerFdForEpoll(int fd) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002061 // TODO(b/121395353) - consider adding EPOLLRDHUP
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002062 struct epoll_event eventItem = {};
2063 eventItem.events = EPOLLIN | EPOLLWAKEUP;
2064 eventItem.data.fd = fd;
2065 if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
2066 ALOGE("Could not add fd to epoll instance: %s", strerror(errno));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002067 return -errno;
2068 }
2069 return OK;
2070}
2071
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002072status_t EventHub::unregisterFdFromEpoll(int fd) {
2073 if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, nullptr)) {
2074 ALOGW("Could not remove fd from epoll instance: %s", strerror(errno));
2075 return -errno;
2076 }
2077 return OK;
2078}
2079
Chris Ye989bb932020-07-04 16:18:59 -07002080status_t EventHub::registerDeviceForEpollLocked(Device& device) {
2081 status_t result = registerFdForEpoll(device.fd);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002082 if (result != OK) {
Chris Ye989bb932020-07-04 16:18:59 -07002083 ALOGE("Could not add input device fd to epoll for device %" PRId32, device.id);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002084 return result;
2085 }
Chris Ye989bb932020-07-04 16:18:59 -07002086 if (device.videoDevice) {
2087 registerVideoDeviceForEpollLocked(*device.videoDevice);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002088 }
2089 return result;
2090}
2091
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002092void EventHub::registerVideoDeviceForEpollLocked(const TouchVideoDevice& videoDevice) {
2093 status_t result = registerFdForEpoll(videoDevice.getFd());
2094 if (result != OK) {
2095 ALOGE("Could not add video device %s to epoll", videoDevice.getName().c_str());
2096 }
2097}
2098
Chris Ye989bb932020-07-04 16:18:59 -07002099status_t EventHub::unregisterDeviceFromEpollLocked(Device& device) {
2100 if (device.hasValidFd()) {
2101 status_t result = unregisterFdFromEpoll(device.fd);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002102 if (result != OK) {
Chris Ye989bb932020-07-04 16:18:59 -07002103 ALOGW("Could not remove input device fd from epoll for device %" PRId32, device.id);
Siarhei Vishniakou25920312018-12-12 15:24:44 -08002104 return result;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002105 }
2106 }
Chris Ye989bb932020-07-04 16:18:59 -07002107 if (device.videoDevice) {
2108 unregisterVideoDeviceFromEpollLocked(*device.videoDevice);
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002109 }
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002110 return OK;
2111}
2112
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002113void EventHub::unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& videoDevice) {
2114 if (videoDevice.hasValidFd()) {
2115 status_t result = unregisterFdFromEpoll(videoDevice.getFd());
2116 if (result != OK) {
2117 ALOGW("Could not remove video device fd from epoll for device: %s",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002118 videoDevice.getName().c_str());
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002119 }
2120 }
2121}
2122
Chris Yed3fef462021-03-07 17:10:08 -08002123void EventHub::reportDeviceAddedForStatisticsLocked(const InputDeviceIdentifier& identifier,
Dominik Laskowski2f01d772022-03-23 16:01:29 -07002124 ftl::Flags<InputDeviceClass> classes) {
Chris Ye657c2f02021-05-25 16:24:37 -07002125 SHA256_CTX ctx;
2126 SHA256_Init(&ctx);
2127 SHA256_Update(&ctx, reinterpret_cast<const uint8_t*>(identifier.uniqueId.c_str()),
2128 identifier.uniqueId.size());
2129 std::array<uint8_t, SHA256_DIGEST_LENGTH> digest;
2130 SHA256_Final(digest.data(), &ctx);
2131
2132 std::string obfuscatedId;
2133 for (size_t i = 0; i < OBFUSCATED_LENGTH; i++) {
2134 obfuscatedId += StringPrintf("%02x", digest[i]);
2135 }
2136
Chris Yed3fef462021-03-07 17:10:08 -08002137 android::util::stats_write(android::util::INPUTDEVICE_REGISTERED, identifier.name.c_str(),
2138 identifier.vendor, identifier.product, identifier.version,
Chris Ye657c2f02021-05-25 16:24:37 -07002139 identifier.bus, obfuscatedId.c_str(), classes.get());
Chris Yed3fef462021-03-07 17:10:08 -08002140}
2141
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002142void EventHub::openDeviceLocked(const std::string& devicePath) {
2143 // If an input device happens to register around the time when EventHub's constructor runs, it
2144 // is possible that the same input event node (for example, /dev/input/event3) will be noticed
2145 // in both 'inotify' callback and also in the 'scanDirLocked' pass. To prevent duplicate devices
2146 // from getting registered, ensure that this path is not already covered by an existing device.
2147 for (const auto& [deviceId, device] : mDevices) {
2148 if (device->path == devicePath) {
2149 return; // device was already registered
2150 }
2151 }
2152
Michael Wrightd02c5b62014-02-10 15:10:22 -08002153 char buffer[80];
2154
Chris Ye8594e192020-07-14 10:34:06 -07002155 ALOGV("Opening device: %s", devicePath.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002156
Chris Ye8594e192020-07-14 10:34:06 -07002157 int fd = open(devicePath.c_str(), O_RDWR | O_CLOEXEC | O_NONBLOCK);
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002158 if (fd < 0) {
Chris Ye8594e192020-07-14 10:34:06 -07002159 ALOGE("could not open %s, %s\n", devicePath.c_str(), strerror(errno));
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002160 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002161 }
2162
2163 InputDeviceIdentifier identifier;
2164
2165 // Get device name.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002166 if (ioctl(fd, EVIOCGNAME(sizeof(buffer) - 1), &buffer) < 1) {
Chris Ye8594e192020-07-14 10:34:06 -07002167 ALOGE("Could not get device name for %s: %s", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002168 } else {
2169 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002170 identifier.name = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002171 }
2172
2173 // Check to see if the device is on our excluded list
2174 for (size_t i = 0; i < mExcludedDevices.size(); i++) {
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002175 const std::string& item = mExcludedDevices[i];
Michael Wrightd02c5b62014-02-10 15:10:22 -08002176 if (identifier.name == item) {
Chris Ye8594e192020-07-14 10:34:06 -07002177 ALOGI("ignoring event id %s driver %s\n", devicePath.c_str(), item.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002178 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002179 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002180 }
2181 }
2182
2183 // Get device driver version.
2184 int driverVersion;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002185 if (ioctl(fd, EVIOCGVERSION, &driverVersion)) {
Chris Ye8594e192020-07-14 10:34:06 -07002186 ALOGE("could not get driver version for %s, %s\n", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002187 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002188 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002189 }
2190
2191 // Get device identifier.
2192 struct input_id inputId;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002193 if (ioctl(fd, EVIOCGID, &inputId)) {
Chris Ye8594e192020-07-14 10:34:06 -07002194 ALOGE("could not get device input id for %s, %s\n", devicePath.c_str(), strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002195 close(fd);
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002196 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002197 }
2198 identifier.bus = inputId.bustype;
2199 identifier.product = inputId.product;
2200 identifier.vendor = inputId.vendor;
2201 identifier.version = inputId.version;
2202
2203 // Get device physical location.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002204 if (ioctl(fd, EVIOCGPHYS(sizeof(buffer) - 1), &buffer) < 1) {
2205 // fprintf(stderr, "could not get location for %s, %s\n", devicePath, strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002206 } else {
2207 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002208 identifier.location = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002209 }
2210
2211 // Get device unique id.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002212 if (ioctl(fd, EVIOCGUNIQ(sizeof(buffer) - 1), &buffer) < 1) {
2213 // fprintf(stderr, "could not get idstring for %s, %s\n", devicePath, strerror(errno));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002214 } else {
2215 buffer[sizeof(buffer) - 1] = '\0';
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002216 identifier.uniqueId = buffer;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002217 }
2218
Prabir Pradhan07525ef2022-10-03 21:51:26 +00002219 // Attempt to get the bluetooth address of an input device from the uniqueId.
2220 if (identifier.bus == BUS_BLUETOOTH &&
2221 std::regex_match(identifier.uniqueId,
2222 std::regex("^[A-Fa-f0-9]{2}(?::[A-Fa-f0-9]{2}){5}$"))) {
2223 identifier.bluetoothAddress = identifier.uniqueId;
2224 // The Bluetooth stack requires alphabetic characters to be uppercase in a valid address.
2225 for (auto& c : *identifier.bluetoothAddress) {
2226 c = ::toupper(c);
2227 }
2228 }
2229
Michael Wrightd02c5b62014-02-10 15:10:22 -08002230 // Fill in the descriptor.
2231 assignDescriptorLocked(identifier);
2232
Michael Wrightd02c5b62014-02-10 15:10:22 -08002233 // Allocate device. (The device object takes ownership of the fd at this point.)
2234 int32_t deviceId = mNextDeviceId++;
Prabir Pradhancb42b472022-08-23 16:01:19 +00002235 std::unique_ptr<Device> device =
2236 std::make_unique<Device>(fd, deviceId, devicePath, identifier,
2237 obtainAssociatedDeviceLocked(devicePath));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002238
Chris Ye8594e192020-07-14 10:34:06 -07002239 ALOGV("add device %d: %s\n", deviceId, devicePath.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002240 ALOGV(" bus: %04x\n"
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002241 " vendor %04x\n"
2242 " product %04x\n"
2243 " version %04x\n",
2244 identifier.bus, identifier.vendor, identifier.product, identifier.version);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002245 ALOGV(" name: \"%s\"\n", identifier.name.c_str());
2246 ALOGV(" location: \"%s\"\n", identifier.location.c_str());
2247 ALOGV(" unique id: \"%s\"\n", identifier.uniqueId.c_str());
2248 ALOGV(" descriptor: \"%s\"\n", identifier.descriptor.c_str());
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002249 ALOGV(" driver: v%d.%d.%d\n", driverVersion >> 16, (driverVersion >> 8) & 0xff,
2250 driverVersion & 0xff);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002251
2252 // Load the configuration file for the device.
Chris Ye989bb932020-07-04 16:18:59 -07002253 device->loadConfigurationLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002254
2255 // Figure out the kinds of events the device reports.
Chris Ye66fbac32020-07-06 20:36:43 -07002256 device->readDeviceBitMask(EVIOCGBIT(EV_KEY, 0), device->keyBitmask);
2257 device->readDeviceBitMask(EVIOCGBIT(EV_ABS, 0), device->absBitmask);
2258 device->readDeviceBitMask(EVIOCGBIT(EV_REL, 0), device->relBitmask);
2259 device->readDeviceBitMask(EVIOCGBIT(EV_SW, 0), device->swBitmask);
2260 device->readDeviceBitMask(EVIOCGBIT(EV_LED, 0), device->ledBitmask);
2261 device->readDeviceBitMask(EVIOCGBIT(EV_FF, 0), device->ffBitmask);
Chris Yef59a2f42020-10-16 12:55:26 -07002262 device->readDeviceBitMask(EVIOCGBIT(EV_MSC, 0), device->mscBitmask);
Chris Ye66fbac32020-07-06 20:36:43 -07002263 device->readDeviceBitMask(EVIOCGPROP(0), device->propBitmask);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002264
Prabir Pradhane1a41a82022-10-14 18:06:50 +00002265 // See if this is a device with keys. This could be full keyboard, or other devices like
2266 // gamepads, joysticks, and styluses with buttons that should generate key presses.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002267 bool haveKeyboardKeys =
Chris Ye66fbac32020-07-06 20:36:43 -07002268 device->keyBitmask.any(0, BTN_MISC) || device->keyBitmask.any(BTN_WHEEL, KEY_MAX + 1);
2269 bool haveGamepadButtons = device->keyBitmask.any(BTN_MISC, BTN_MOUSE) ||
2270 device->keyBitmask.any(BTN_JOYSTICK, BTN_DIGI);
Prabir Pradhane1a41a82022-10-14 18:06:50 +00002271 bool haveStylusButtons = device->keyBitmask.test(BTN_STYLUS) ||
2272 device->keyBitmask.test(BTN_STYLUS2) || device->keyBitmask.test(BTN_STYLUS3);
2273 if (haveKeyboardKeys || haveGamepadButtons || haveStylusButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002274 device->classes |= InputDeviceClass::KEYBOARD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002275 }
2276
2277 // See if this is a cursor device such as a trackball or mouse.
Chris Ye66fbac32020-07-06 20:36:43 -07002278 if (device->keyBitmask.test(BTN_MOUSE) && device->relBitmask.test(REL_X) &&
2279 device->relBitmask.test(REL_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002280 device->classes |= InputDeviceClass::CURSOR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002281 }
2282
Prabir Pradhana3621852022-10-14 18:57:23 +00002283 // See if the device is specially configured to be of a certain type.
Siarhei Vishniakou4f94c1a2022-07-13 07:29:51 -07002284 std::string deviceType;
2285 if (device->configuration && device->configuration->tryGetProperty("device.type", deviceType)) {
2286 if (deviceType == "rotaryEncoder") {
Chris Ye1b0c7342020-07-28 21:57:03 -07002287 device->classes |= InputDeviceClass::ROTARY_ENCODER;
Prabir Pradhana3621852022-10-14 18:57:23 +00002288 } else if (deviceType == "externalStylus") {
2289 device->classes |= InputDeviceClass::EXTERNAL_STYLUS;
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002290 }
Prashant Malani1941ff52015-08-11 18:29:28 -07002291 }
2292
Michael Wrightd02c5b62014-02-10 15:10:22 -08002293 // See if this is a touch pad.
2294 // Is this a new modern multi-touch driver?
Chris Ye66fbac32020-07-06 20:36:43 -07002295 if (device->absBitmask.test(ABS_MT_POSITION_X) && device->absBitmask.test(ABS_MT_POSITION_Y)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002296 // Some joysticks such as the PS3 controller report axes that conflict
2297 // with the ABS_MT range. Try to confirm that the device really is
2298 // a touch screen.
Chris Ye66fbac32020-07-06 20:36:43 -07002299 if (device->keyBitmask.test(BTN_TOUCH) || !haveGamepadButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002300 device->classes |= (InputDeviceClass::TOUCH | InputDeviceClass::TOUCH_MT);
Harry Cutts79cc9fa2022-10-28 15:32:39 +00002301 if (device->propBitmask.test(INPUT_PROP_POINTER) &&
2302 !device->keyBitmask.any(BTN_TOOL_PEN, BTN_TOOL_FINGER) && !haveStylusButtons) {
2303 device->classes |= InputDeviceClass::TOUCHPAD;
2304 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002305 }
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002306 // Is this an old style single-touch driver?
Chris Ye66fbac32020-07-06 20:36:43 -07002307 } else if (device->keyBitmask.test(BTN_TOUCH) && device->absBitmask.test(ABS_X) &&
2308 device->absBitmask.test(ABS_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002309 device->classes |= InputDeviceClass::TOUCH;
Prabir Pradhane1a41a82022-10-14 18:06:50 +00002310 // Is this a stylus that reports contact/pressure independently of touch coordinates?
Chris Ye66fbac32020-07-06 20:36:43 -07002311 } else if ((device->absBitmask.test(ABS_PRESSURE) || device->keyBitmask.test(BTN_TOUCH)) &&
2312 !device->absBitmask.test(ABS_X) && !device->absBitmask.test(ABS_Y)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002313 device->classes |= InputDeviceClass::EXTERNAL_STYLUS;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002314 }
2315
2316 // See if this device is a joystick.
2317 // Assumes that joysticks always have gamepad buttons in order to distinguish them
2318 // from other devices such as accelerometers that also have absolute axes.
2319 if (haveGamepadButtons) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002320 auto assumedClasses = device->classes | InputDeviceClass::JOYSTICK;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002321 for (int i = 0; i <= ABS_MAX; i++) {
Chris Ye66fbac32020-07-06 20:36:43 -07002322 if (device->absBitmask.test(i) &&
Chris Ye1b0c7342020-07-28 21:57:03 -07002323 (getAbsAxisUsage(i, assumedClasses).test(InputDeviceClass::JOYSTICK))) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002324 device->classes = assumedClasses;
2325 break;
2326 }
2327 }
2328 }
2329
Chris Yef59a2f42020-10-16 12:55:26 -07002330 // Check whether this device is an accelerometer.
2331 if (device->propBitmask.test(INPUT_PROP_ACCELEROMETER)) {
2332 device->classes |= InputDeviceClass::SENSOR;
2333 }
2334
Michael Wrightd02c5b62014-02-10 15:10:22 -08002335 // Check whether this device has switches.
2336 for (int i = 0; i <= SW_MAX; i++) {
Chris Ye66fbac32020-07-06 20:36:43 -07002337 if (device->swBitmask.test(i)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002338 device->classes |= InputDeviceClass::SWITCH;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002339 break;
2340 }
2341 }
2342
2343 // Check whether this device supports the vibrator.
Chris Ye66fbac32020-07-06 20:36:43 -07002344 if (device->ffBitmask.test(FF_RUMBLE)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002345 device->classes |= InputDeviceClass::VIBRATOR;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002346 }
2347
2348 // Configure virtual keys.
Chris Ye1b0c7342020-07-28 21:57:03 -07002349 if ((device->classes.test(InputDeviceClass::TOUCH))) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002350 // Load the virtual keys for the touch screen, if any.
2351 // We do this now so that we can make sure to load the keymap if necessary.
Chris Ye989bb932020-07-04 16:18:59 -07002352 bool success = device->loadVirtualKeyMapLocked();
Siarhei Vishniakou3e78dec2019-02-20 16:21:46 -06002353 if (success) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002354 device->classes |= InputDeviceClass::KEYBOARD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002355 }
2356 }
2357
2358 // Load the key map.
Chris Yef59a2f42020-10-16 12:55:26 -07002359 // We need to do this for joysticks too because the key layout may specify axes, and for
2360 // sensor as well because the key layout may specify the axes to sensor data mapping.
Michael Wrightd02c5b62014-02-10 15:10:22 -08002361 status_t keyMapStatus = NAME_NOT_FOUND;
Chris Yef59a2f42020-10-16 12:55:26 -07002362 if (device->classes.any(InputDeviceClass::KEYBOARD | InputDeviceClass::JOYSTICK |
2363 InputDeviceClass::SENSOR)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002364 // Load the keymap for the device.
Chris Ye989bb932020-07-04 16:18:59 -07002365 keyMapStatus = device->loadKeyMapLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002366 }
2367
2368 // Configure the keyboard, gamepad or virtual keyboard.
Chris Ye1b0c7342020-07-28 21:57:03 -07002369 if (device->classes.test(InputDeviceClass::KEYBOARD)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002370 // Register the keyboard as a built-in keyboard if it is eligible.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002371 if (!keyMapStatus && mBuiltInKeyboardId == NO_BUILT_IN_KEYBOARD &&
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002372 isEligibleBuiltInKeyboard(device->identifier, device->configuration.get(),
2373 &device->keyMap)) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002374 mBuiltInKeyboardId = device->id;
2375 }
2376
2377 // 'Q' key support = cheap test of whether this is an alpha-capable kbd
Chris Ye989bb932020-07-04 16:18:59 -07002378 if (device->hasKeycodeLocked(AKEYCODE_Q)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002379 device->classes |= InputDeviceClass::ALPHAKEY;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002380 }
2381
2382 // See if this device has a DPAD.
Chris Ye989bb932020-07-04 16:18:59 -07002383 if (device->hasKeycodeLocked(AKEYCODE_DPAD_UP) &&
2384 device->hasKeycodeLocked(AKEYCODE_DPAD_DOWN) &&
2385 device->hasKeycodeLocked(AKEYCODE_DPAD_LEFT) &&
2386 device->hasKeycodeLocked(AKEYCODE_DPAD_RIGHT) &&
2387 device->hasKeycodeLocked(AKEYCODE_DPAD_CENTER)) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002388 device->classes |= InputDeviceClass::DPAD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002389 }
2390
2391 // See if this device has a gamepad.
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002392 for (size_t i = 0; i < sizeof(GAMEPAD_KEYCODES) / sizeof(GAMEPAD_KEYCODES[0]); i++) {
Chris Ye989bb932020-07-04 16:18:59 -07002393 if (device->hasKeycodeLocked(GAMEPAD_KEYCODES[i])) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002394 device->classes |= InputDeviceClass::GAMEPAD;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002395 break;
2396 }
2397 }
Prabir Pradhana3621852022-10-14 18:57:23 +00002398
2399 // See if this device has any stylus buttons that we would want to fuse with touch data.
2400 if (!device->classes.any(InputDeviceClass::TOUCH | InputDeviceClass::TOUCH_MT)) {
2401 for (int32_t keycode : STYLUS_BUTTON_KEYCODES) {
2402 if (device->hasKeycodeLocked(keycode)) {
2403 device->classes |= InputDeviceClass::EXTERNAL_STYLUS;
2404 break;
2405 }
2406 }
2407 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002408 }
2409
2410 // If the device isn't recognized as something we handle, don't monitor it.
Dominik Laskowski2f01d772022-03-23 16:01:29 -07002411 if (device->classes == ftl::Flags<InputDeviceClass>(0)) {
Chris Ye8594e192020-07-14 10:34:06 -07002412 ALOGV("Dropping device: id=%d, path='%s', name='%s'", deviceId, devicePath.c_str(),
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002413 device->identifier.name.c_str());
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002414 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002415 }
2416
Chris Ye3fdbfef2021-01-06 18:45:18 -08002417 // Classify InputDeviceClass::BATTERY.
Prabir Pradhan51894782022-08-23 16:29:10 +00002418 if (device->associatedDevice && !device->associatedDevice->batteryInfos.empty()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08002419 device->classes |= InputDeviceClass::BATTERY;
2420 }
Kim Low03ea0352020-11-06 12:45:07 -08002421
Chris Ye3fdbfef2021-01-06 18:45:18 -08002422 // Classify InputDeviceClass::LIGHT.
Prabir Pradhan51894782022-08-23 16:29:10 +00002423 if (device->associatedDevice && !device->associatedDevice->lightInfos.empty()) {
Chris Ye3fdbfef2021-01-06 18:45:18 -08002424 device->classes |= InputDeviceClass::LIGHT;
Kim Low03ea0352020-11-06 12:45:07 -08002425 }
2426
Tim Kilbourn063ff532015-04-08 10:26:18 -07002427 // Determine whether the device has a mic.
Chris Ye989bb932020-07-04 16:18:59 -07002428 if (device->deviceHasMicLocked()) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002429 device->classes |= InputDeviceClass::MIC;
Tim Kilbourn063ff532015-04-08 10:26:18 -07002430 }
2431
Michael Wrightd02c5b62014-02-10 15:10:22 -08002432 // Determine whether the device is external or internal.
Chris Ye989bb932020-07-04 16:18:59 -07002433 if (device->isExternalDeviceLocked()) {
Chris Ye1b0c7342020-07-28 21:57:03 -07002434 device->classes |= InputDeviceClass::EXTERNAL;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002435 }
2436
Chris Ye1b0c7342020-07-28 21:57:03 -07002437 if (device->classes.any(InputDeviceClass::JOYSTICK | InputDeviceClass::DPAD) &&
2438 device->classes.test(InputDeviceClass::GAMEPAD)) {
Chris Ye989bb932020-07-04 16:18:59 -07002439 device->controllerNumber = getNextControllerNumberLocked(device->identifier.name);
2440 device->setLedForControllerLocked();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002441 }
2442
Chris Ye989bb932020-07-04 16:18:59 -07002443 if (registerDeviceForEpollLocked(*device) != OK) {
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +00002444 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002445 }
2446
Chris Ye989bb932020-07-04 16:18:59 -07002447 device->configureFd();
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002448
Chris Ye1b0c7342020-07-28 21:57:03 -07002449 ALOGI("New device: id=%d, fd=%d, path='%s', name='%s', classes=%s, "
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002450 "configuration='%s', keyLayout='%s', keyCharacterMap='%s', builtinKeyboard=%s, ",
Chris Ye1b0c7342020-07-28 21:57:03 -07002451 deviceId, fd, devicePath.c_str(), device->identifier.name.c_str(),
2452 device->classes.string().c_str(), device->configurationFile.c_str(),
2453 device->keyMap.keyLayoutFile.c_str(), device->keyMap.keyCharacterMapFile.c_str(),
2454 toString(mBuiltInKeyboardId == deviceId));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002455
Chris Ye989bb932020-07-04 16:18:59 -07002456 addDeviceLocked(std::move(device));
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002457}
2458
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002459void EventHub::openVideoDeviceLocked(const std::string& devicePath) {
2460 std::unique_ptr<TouchVideoDevice> videoDevice = TouchVideoDevice::create(devicePath);
2461 if (!videoDevice) {
2462 ALOGE("Could not create touch video device for %s. Ignoring", devicePath.c_str());
2463 return;
2464 }
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002465 // Transfer ownership of this video device to a matching input device
Chris Ye989bb932020-07-04 16:18:59 -07002466 for (const auto& [id, device] : mDevices) {
Chris Yed3fef462021-03-07 17:10:08 -08002467 if (tryAddVideoDeviceLocked(*device, videoDevice)) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05002468 return; // 'device' now owns 'videoDevice'
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002469 }
2470 }
2471
2472 // Couldn't find a matching input device, so just add it to a temporary holding queue.
2473 // A matching input device may appear later.
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002474 ALOGI("Adding video device %s to list of unattached video devices",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002475 videoDevice->getName().c_str());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002476 mUnattachedVideoDevices.push_back(std::move(videoDevice));
2477}
2478
Chris Yed3fef462021-03-07 17:10:08 -08002479bool EventHub::tryAddVideoDeviceLocked(EventHub::Device& device,
2480 std::unique_ptr<TouchVideoDevice>& videoDevice) {
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -05002481 if (videoDevice->getName() != device.identifier.name) {
2482 return false;
2483 }
2484 device.videoDevice = std::move(videoDevice);
2485 if (device.enabled) {
2486 registerVideoDeviceForEpollLocked(*device.videoDevice);
2487 }
2488 return true;
2489}
2490
Prabir Pradhanae4ff282022-08-23 16:21:39 +00002491bool EventHub::isDeviceEnabled(int32_t deviceId) const {
Chris Ye87143712020-11-10 05:05:58 +00002492 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002493 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002494 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002495 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2496 return false;
2497 }
2498 return device->enabled;
2499}
Michael Wrightd02c5b62014-02-10 15:10:22 -08002500
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002501status_t EventHub::enableDevice(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002502 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002503 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002504 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002505 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2506 return BAD_VALUE;
2507 }
2508 if (device->enabled) {
2509 ALOGW("Duplicate call to %s, input device %" PRId32 " already enabled", __func__, deviceId);
2510 return OK;
2511 }
2512 status_t result = device->enable();
2513 if (result != OK) {
2514 ALOGE("Failed to enable device %" PRId32, deviceId);
2515 return result;
2516 }
2517
Chris Ye989bb932020-07-04 16:18:59 -07002518 device->configureFd();
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002519
Chris Ye989bb932020-07-04 16:18:59 -07002520 return registerDeviceForEpollLocked(*device);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002521}
2522
2523status_t EventHub::disableDevice(int32_t deviceId) {
Chris Ye87143712020-11-10 05:05:58 +00002524 std::scoped_lock _l(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002525 Device* device = getDeviceLocked(deviceId);
Yi Kong9b14ac62018-07-17 13:48:38 -07002526 if (device == nullptr) {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002527 ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
2528 return BAD_VALUE;
2529 }
2530 if (!device->enabled) {
2531 ALOGW("Duplicate call to %s, input device already disabled", __func__);
2532 return OK;
2533 }
Chris Ye989bb932020-07-04 16:18:59 -07002534 unregisterDeviceFromEpollLocked(*device);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002535 return device->disable();
Michael Wrightd02c5b62014-02-10 15:10:22 -08002536}
2537
2538void EventHub::createVirtualKeyboardLocked() {
2539 InputDeviceIdentifier identifier;
2540 identifier.name = "Virtual";
2541 identifier.uniqueId = "<virtual>";
2542 assignDescriptorLocked(identifier);
2543
Chris Ye989bb932020-07-04 16:18:59 -07002544 std::unique_ptr<Device> device =
2545 std::make_unique<Device>(-1, ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID, "<virtual>",
Harry Cutts33476232023-01-30 19:57:29 +00002546 identifier, /*associatedDevice=*/nullptr);
Chris Ye1b0c7342020-07-28 21:57:03 -07002547 device->classes = InputDeviceClass::KEYBOARD | InputDeviceClass::ALPHAKEY |
2548 InputDeviceClass::DPAD | InputDeviceClass::VIRTUAL;
Chris Ye989bb932020-07-04 16:18:59 -07002549 device->loadKeyMapLocked();
2550 addDeviceLocked(std::move(device));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002551}
2552
Chris Ye989bb932020-07-04 16:18:59 -07002553void EventHub::addDeviceLocked(std::unique_ptr<Device> device) {
Chris Yed3fef462021-03-07 17:10:08 -08002554 reportDeviceAddedForStatisticsLocked(device->identifier, device->classes);
Chris Ye989bb932020-07-04 16:18:59 -07002555 mOpeningDevices.push_back(std::move(device));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002556}
2557
Chris Ye989bb932020-07-04 16:18:59 -07002558int32_t EventHub::getNextControllerNumberLocked(const std::string& name) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002559 if (mControllerNumbers.isFull()) {
2560 ALOGI("Maximum number of controllers reached, assigning controller number 0 to device %s",
Chris Ye989bb932020-07-04 16:18:59 -07002561 name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002562 return 0;
2563 }
2564 // Since the controller number 0 is reserved for non-controllers, translate all numbers up by
2565 // one
2566 return static_cast<int32_t>(mControllerNumbers.markFirstUnmarkedBit() + 1);
2567}
2568
Chris Ye989bb932020-07-04 16:18:59 -07002569void EventHub::releaseControllerNumberLocked(int32_t num) {
2570 if (num > 0) {
2571 mControllerNumbers.clearBit(static_cast<uint32_t>(num - 1));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002572 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002573}
2574
Chris Ye8594e192020-07-14 10:34:06 -07002575void EventHub::closeDeviceByPathLocked(const std::string& devicePath) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002576 Device* device = getDeviceByPathLocked(devicePath);
Chris Ye989bb932020-07-04 16:18:59 -07002577 if (device != nullptr) {
2578 closeDeviceLocked(*device);
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002579 return;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002580 }
Chris Ye8594e192020-07-14 10:34:06 -07002581 ALOGV("Remove device: %s not found, device may already have been removed.", devicePath.c_str());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002582}
2583
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002584/**
2585 * Find the video device by filename, and close it.
2586 * The video device is closed by path during an inotify event, where we don't have the
2587 * additional context about the video device fd, or the associated input device.
2588 */
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002589void EventHub::closeVideoDeviceByPathLocked(const std::string& devicePath) {
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002590 // A video device may be owned by an existing input device, or it may be stored in
2591 // the mUnattachedVideoDevices queue. Check both locations.
Chris Ye989bb932020-07-04 16:18:59 -07002592 for (const auto& [id, device] : mDevices) {
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002593 if (device->videoDevice && device->videoDevice->getPath() == devicePath) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002594 unregisterVideoDeviceFromEpollLocked(*device->videoDevice);
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002595 device->videoDevice = nullptr;
2596 return;
2597 }
2598 }
Siarhei Vishniakouf47c339e2021-12-30 11:22:26 -08002599 std::erase_if(mUnattachedVideoDevices,
2600 [&devicePath](const std::unique_ptr<TouchVideoDevice>& videoDevice) {
2601 return videoDevice->getPath() == devicePath;
2602 });
Michael Wrightd02c5b62014-02-10 15:10:22 -08002603}
2604
2605void EventHub::closeAllDevicesLocked() {
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002606 mUnattachedVideoDevices.clear();
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002607 while (!mDevices.empty()) {
2608 closeDeviceLocked(*(mDevices.begin()->second));
Michael Wrightd02c5b62014-02-10 15:10:22 -08002609 }
2610}
2611
Chris Ye989bb932020-07-04 16:18:59 -07002612void EventHub::closeDeviceLocked(Device& device) {
2613 ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=%s", device.path.c_str(),
2614 device.identifier.name.c_str(), device.id, device.fd, device.classes.string().c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002615
Chris Ye989bb932020-07-04 16:18:59 -07002616 if (device.id == mBuiltInKeyboardId) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002617 ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this",
Chris Ye989bb932020-07-04 16:18:59 -07002618 device.path.c_str(), mBuiltInKeyboardId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002619 mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD;
2620 }
2621
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -07002622 unregisterDeviceFromEpollLocked(device);
Chris Ye989bb932020-07-04 16:18:59 -07002623 if (device.videoDevice) {
Siarhei Vishniakou12598682018-11-02 17:19:19 -07002624 // This must be done after the video device is removed from epoll
Chris Ye989bb932020-07-04 16:18:59 -07002625 mUnattachedVideoDevices.push_back(std::move(device.videoDevice));
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -08002626 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002627
Chris Ye989bb932020-07-04 16:18:59 -07002628 releaseControllerNumberLocked(device.controllerNumber);
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002629 device.controllerNumber = 0;
Chris Ye989bb932020-07-04 16:18:59 -07002630 device.close();
Chris Ye989bb932020-07-04 16:18:59 -07002631 mClosingDevices.push_back(std::move(mDevices[device.id]));
Siarhei Vishniakoud549b252020-08-11 11:25:26 -05002632
Chris Ye989bb932020-07-04 16:18:59 -07002633 mDevices.erase(device.id);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002634}
2635
Prabir Pradhan952e65b2022-06-23 17:49:55 +00002636base::Result<void> EventHub::readNotifyLocked() {
2637 static constexpr auto EVENT_SIZE = static_cast<ssize_t>(sizeof(inotify_event));
2638 uint8_t eventBuffer[512];
2639 ssize_t sizeRead;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002640
2641 ALOGV("EventHub::readNotify nfd: %d\n", mINotifyFd);
Prabir Pradhan952e65b2022-06-23 17:49:55 +00002642 do {
2643 sizeRead = read(mINotifyFd, eventBuffer, sizeof(eventBuffer));
2644 } while (sizeRead < 0 && errno == EINTR);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002645
Prabir Pradhan952e65b2022-06-23 17:49:55 +00002646 if (sizeRead < EVENT_SIZE) return Errorf("could not get event, %s", strerror(errno));
2647
2648 for (ssize_t eventPos = 0; sizeRead >= EVENT_SIZE;) {
2649 const inotify_event* event;
2650 event = (const inotify_event*)(eventBuffer + eventPos);
2651 if (event->len == 0) continue;
2652
2653 handleNotifyEventLocked(*event);
2654
2655 const ssize_t eventSize = EVENT_SIZE + event->len;
2656 sizeRead -= eventSize;
2657 eventPos += eventSize;
Michael Wrightd02c5b62014-02-10 15:10:22 -08002658 }
Prabir Pradhan952e65b2022-06-23 17:49:55 +00002659 return {};
2660}
2661
2662void EventHub::handleNotifyEventLocked(const inotify_event& event) {
2663 if (event.wd == mDeviceInputWd) {
2664 std::string filename = std::string(DEVICE_INPUT_PATH) + "/" + event.name;
2665 if (event.mask & IN_CREATE) {
2666 openDeviceLocked(filename);
2667 } else {
2668 ALOGI("Removing device '%s' due to inotify event\n", filename.c_str());
2669 closeDeviceByPathLocked(filename);
2670 }
2671 } else if (event.wd == mDeviceWd) {
2672 if (isV4lTouchNode(event.name)) {
2673 std::string filename = std::string(DEVICE_PATH) + "/" + event.name;
2674 if (event.mask & IN_CREATE) {
2675 openVideoDeviceLocked(filename);
2676 } else {
2677 ALOGI("Removing video device '%s' due to inotify event", filename.c_str());
2678 closeVideoDeviceByPathLocked(filename);
2679 }
2680 } else if (strcmp(event.name, "input") == 0 && event.mask & IN_CREATE) {
2681 addDeviceInputInotify();
2682 }
2683 } else {
2684 LOG_ALWAYS_FATAL("Unexpected inotify event, wd = %i", event.wd);
2685 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002686}
2687
Chris Ye8594e192020-07-14 10:34:06 -07002688status_t EventHub::scanDirLocked(const std::string& dirname) {
2689 for (const auto& entry : std::filesystem::directory_iterator(dirname)) {
2690 openDeviceLocked(entry.path());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002691 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002692 return 0;
2693}
2694
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002695/**
2696 * Look for all dirname/v4l-touch* devices, and open them.
2697 */
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002698status_t EventHub::scanVideoDirLocked(const std::string& dirname) {
Chris Ye8594e192020-07-14 10:34:06 -07002699 for (const auto& entry : std::filesystem::directory_iterator(dirname)) {
2700 if (isV4lTouchNode(entry.path())) {
2701 ALOGI("Found touch video device %s", entry.path().c_str());
2702 openVideoDeviceLocked(entry.path());
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002703 }
2704 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002705 return OK;
2706}
2707
Michael Wrightd02c5b62014-02-10 15:10:22 -08002708void EventHub::requestReopenDevices() {
2709 ALOGV("requestReopenDevices() called");
2710
Chris Ye87143712020-11-10 05:05:58 +00002711 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002712 mNeedToReopenDevices = true;
2713}
2714
Prabir Pradhanae4ff282022-08-23 16:21:39 +00002715void EventHub::dump(std::string& dump) const {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002716 dump += "Event Hub State:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002717
2718 { // acquire lock
Chris Ye87143712020-11-10 05:05:58 +00002719 std::scoped_lock _l(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002720
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002721 dump += StringPrintf(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002722
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002723 dump += INDENT "Devices:\n";
Michael Wrightd02c5b62014-02-10 15:10:22 -08002724
Chris Ye989bb932020-07-04 16:18:59 -07002725 for (const auto& [id, device] : mDevices) {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002726 if (mBuiltInKeyboardId == device->id) {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002727 dump += StringPrintf(INDENT2 "%d: %s (aka device 0 - built-in keyboard)\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002728 device->id, device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002729 } else {
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002730 dump += StringPrintf(INDENT2 "%d: %s\n", device->id,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002731 device->identifier.name.c_str());
Michael Wrightd02c5b62014-02-10 15:10:22 -08002732 }
Chris Ye1b0c7342020-07-28 21:57:03 -07002733 dump += StringPrintf(INDENT3 "Classes: %s\n", device->classes.string().c_str());
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002734 dump += StringPrintf(INDENT3 "Path: %s\n", device->path.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002735 dump += StringPrintf(INDENT3 "Enabled: %s\n", toString(device->enabled));
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002736 dump += StringPrintf(INDENT3 "Descriptor: %s\n", device->identifier.descriptor.c_str());
2737 dump += StringPrintf(INDENT3 "Location: %s\n", device->identifier.location.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002738 dump += StringPrintf(INDENT3 "ControllerNumber: %d\n", device->controllerNumber);
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +01002739 dump += StringPrintf(INDENT3 "UniqueId: %s\n", device->identifier.uniqueId.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002740 dump += StringPrintf(INDENT3 "Identifier: bus=0x%04x, vendor=0x%04x, "
Prabir Pradhan07525ef2022-10-03 21:51:26 +00002741 "product=0x%04x, version=0x%04x, bluetoothAddress=%s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002742 device->identifier.bus, device->identifier.vendor,
Prabir Pradhan07525ef2022-10-03 21:51:26 +00002743 device->identifier.product, device->identifier.version,
2744 toString(device->identifier.bluetoothAddress).c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002745 dump += StringPrintf(INDENT3 "KeyLayoutFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002746 device->keyMap.keyLayoutFile.c_str());
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002747 dump += StringPrintf(INDENT3 "KeyCharacterMapFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002748 device->keyMap.keyCharacterMapFile.c_str());
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +00002749 if (device->associatedDevice && device->associatedDevice->layoutInfo) {
2750 dump += StringPrintf(INDENT3 "LanguageTag: %s\n",
2751 device->associatedDevice->layoutInfo->languageTag.c_str());
2752 dump += StringPrintf(INDENT3 "LayoutType: %s\n",
2753 device->associatedDevice->layoutInfo->layoutType.c_str());
2754 }
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08002755 dump += StringPrintf(INDENT3 "ConfigurationFile: %s\n",
Prabir Pradhanda7c00c2019-08-29 14:12:42 -07002756 device->configurationFile.c_str());
Prabir Pradhan51894782022-08-23 16:29:10 +00002757 dump += StringPrintf(INDENT3 "VideoDevice: %s\n",
2758 device->videoDevice ? device->videoDevice->dump().c_str()
2759 : "<none>");
2760 dump += StringPrintf(INDENT3 "SysfsDevicePath: %s\n",
2761 device->associatedDevice
2762 ? device->associatedDevice->sysfsRootPath.c_str()
2763 : "<none>");
Michael Wrightd02c5b62014-02-10 15:10:22 -08002764 }
Siarhei Vishniakou22c88462018-12-13 19:34:53 -08002765
2766 dump += INDENT "Unattached video devices:\n";
2767 for (const std::unique_ptr<TouchVideoDevice>& videoDevice : mUnattachedVideoDevices) {
2768 dump += INDENT2 + videoDevice->dump() + "\n";
2769 }
2770 if (mUnattachedVideoDevices.empty()) {
2771 dump += INDENT2 "<none>\n";
2772 }
Michael Wrightd02c5b62014-02-10 15:10:22 -08002773 } // release lock
2774}
2775
Prabir Pradhanae4ff282022-08-23 16:21:39 +00002776void EventHub::monitor() const {
Michael Wrightd02c5b62014-02-10 15:10:22 -08002777 // Acquire and release the lock to ensure that the event hub has not deadlocked.
Chris Ye1c2e0892020-11-30 21:41:44 -08002778 std::unique_lock<std::mutex> lock(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -08002779}
2780
Prabir Pradhanedeec3b2022-08-26 22:33:55 +00002781std::string EventHub::AssociatedDevice::dump() const {
2782 return StringPrintf("path=%s, numBatteries=%zu, numLight=%zu", sysfsRootPath.c_str(),
2783 batteryInfos.size(), lightInfos.size());
2784}
2785
Prabir Pradhanae4ff282022-08-23 16:21:39 +00002786} // namespace android