blob: 1016a2c409f32ad18411be195eedb3622981e2f0 [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
Michael Wrightd02c5b62014-02-10 15:10:22 -080017#ifndef _RUNTIME_EVENT_HUB_H
18#define _RUNTIME_EVENT_HUB_H
19
Chris Ye66fbac32020-07-06 20:36:43 -070020#include <bitset>
21#include <climits>
Chris Ye989bb932020-07-04 16:18:59 -070022#include <unordered_map>
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +010023#include <vector>
24
chaviw98318de2021-05-19 16:45:23 -050025#include <ftl/Flags.h>
Kim Low03ea0352020-11-06 12:45:07 -080026#include <filesystem>
27
28#include <batteryservice/BatteryService.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080029#include <input/Input.h>
30#include <input/InputDevice.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080031#include <input/KeyCharacterMap.h>
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070032#include <input/KeyLayoutMap.h>
33#include <input/Keyboard.h>
Siarhei Vishniakou32f36ae2020-09-02 20:17:10 -070034#include <input/PropertyMap.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080035#include <input/VirtualKeyMap.h>
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +000036#include <linux/input.h>
37#include <sys/epoll.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080038#include <utils/BitSet.h>
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070039#include <utils/Errors.h>
40#include <utils/KeyedVector.h>
41#include <utils/List.h>
42#include <utils/Log.h>
43#include <utils/Mutex.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080044
Siarhei Vishniakou22c88462018-12-13 19:34:53 -080045#include "TouchVideoDevice.h"
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +000046#include "VibrationElement.h"
Siarhei Vishniakou22c88462018-12-13 19:34:53 -080047
Michael Wrightd02c5b62014-02-10 15:10:22 -080048namespace android {
49
Chris Ye3fdbfef2021-01-06 18:45:18 -080050/* Number of colors : {red, green, blue} */
51static constexpr size_t COLOR_NUM = 3;
Michael Wrightd02c5b62014-02-10 15:10:22 -080052/*
53 * A raw event as retrieved from the EventHub.
54 */
55struct RawEvent {
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +000056 // Time when the event happened
Michael Wrightd02c5b62014-02-10 15:10:22 -080057 nsecs_t when;
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +000058 // Time when the event was read by EventHub. Only populated for input events.
59 // For other events (device added/removed/etc), this value is undefined and should not be read.
60 nsecs_t readTime;
Michael Wrightd02c5b62014-02-10 15:10:22 -080061 int32_t deviceId;
62 int32_t type;
63 int32_t code;
64 int32_t value;
65};
66
67/* Describes an absolute axis. */
68struct RawAbsoluteAxisInfo {
69 bool valid; // true if the information is valid, false otherwise
70
Prabir Pradhanda7c00c2019-08-29 14:12:42 -070071 int32_t minValue; // minimum value
72 int32_t maxValue; // maximum value
73 int32_t flat; // center flat position, eg. flat == 8 means center is between -8 and 8
74 int32_t fuzz; // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise
Michael Wrightd02c5b62014-02-10 15:10:22 -080075 int32_t resolution; // resolution in units per mm or radians per mm
76
77 inline void clear() {
78 valid = false;
79 minValue = 0;
80 maxValue = 0;
81 flat = 0;
82 fuzz = 0;
83 resolution = 0;
84 }
85};
86
87/*
88 * Input device classes.
89 */
Chris Ye1b0c7342020-07-28 21:57:03 -070090enum class InputDeviceClass : uint32_t {
Michael Wrightd02c5b62014-02-10 15:10:22 -080091 /* The input device is a keyboard or has buttons. */
Chris Ye1b0c7342020-07-28 21:57:03 -070092 KEYBOARD = 0x00000001,
Michael Wrightd02c5b62014-02-10 15:10:22 -080093
94 /* The input device is an alpha-numeric keyboard (not just a dial pad). */
Chris Ye1b0c7342020-07-28 21:57:03 -070095 ALPHAKEY = 0x00000002,
Michael Wrightd02c5b62014-02-10 15:10:22 -080096
97 /* The input device is a touchscreen or a touchpad (either single-touch or multi-touch). */
Chris Ye1b0c7342020-07-28 21:57:03 -070098 TOUCH = 0x00000004,
Michael Wrightd02c5b62014-02-10 15:10:22 -080099
100 /* The input device is a cursor device such as a trackball or mouse. */
Chris Ye1b0c7342020-07-28 21:57:03 -0700101 CURSOR = 0x00000008,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800102
103 /* The input device is a multi-touch touchscreen. */
Chris Ye1b0c7342020-07-28 21:57:03 -0700104 TOUCH_MT = 0x00000010,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800105
106 /* The input device is a directional pad (implies keyboard, has DPAD keys). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700107 DPAD = 0x00000020,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800108
109 /* The input device is a gamepad (implies keyboard, has BUTTON keys). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700110 GAMEPAD = 0x00000040,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800111
112 /* The input device has switches. */
Chris Ye1b0c7342020-07-28 21:57:03 -0700113 SWITCH = 0x00000080,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800114
115 /* The input device is a joystick (implies gamepad, has joystick absolute axes). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700116 JOYSTICK = 0x00000100,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800117
118 /* The input device has a vibrator (supports FF_RUMBLE). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700119 VIBRATOR = 0x00000200,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800120
Tim Kilbourn063ff532015-04-08 10:26:18 -0700121 /* The input device has a microphone. */
Chris Ye1b0c7342020-07-28 21:57:03 -0700122 MIC = 0x00000400,
Tim Kilbourn063ff532015-04-08 10:26:18 -0700123
Michael Wright842500e2015-03-13 17:32:02 -0700124 /* The input device is an external stylus (has data we want to fuse with touch data). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700125 EXTERNAL_STYLUS = 0x00000800,
Michael Wright842500e2015-03-13 17:32:02 -0700126
Prashant Malani1941ff52015-08-11 18:29:28 -0700127 /* The input device has a rotary encoder */
Chris Ye1b0c7342020-07-28 21:57:03 -0700128 ROTARY_ENCODER = 0x00001000,
Prashant Malani1941ff52015-08-11 18:29:28 -0700129
Chris Yef59a2f42020-10-16 12:55:26 -0700130 /* The input device has a sensor like accelerometer, gyro, etc */
131 SENSOR = 0x00002000,
132
Kim Low03ea0352020-11-06 12:45:07 -0800133 /* The input device has a battery */
134 BATTERY = 0x00004000,
135
Chris Ye3fdbfef2021-01-06 18:45:18 -0800136 /* The input device has sysfs controllable lights */
137 LIGHT = 0x00008000,
138
Michael Wrightd02c5b62014-02-10 15:10:22 -0800139 /* The input device is virtual (not a real device, not part of UI configuration). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700140 VIRTUAL = 0x40000000,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800141
142 /* The input device is external (not built-in). */
Chris Ye1b0c7342020-07-28 21:57:03 -0700143 EXTERNAL = 0x80000000,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800144};
145
Chris Ye3fdbfef2021-01-06 18:45:18 -0800146enum class SysfsClass : uint32_t {
147 POWER_SUPPLY = 0,
148 LEDS = 1,
149};
150
151enum class LightColor : uint32_t {
152 RED = 0,
153 GREEN = 1,
154 BLUE = 2,
155};
156
157enum class InputLightClass : uint32_t {
158 /* The input light has brightness node. */
159 BRIGHTNESS = 0x00000001,
160 /* The input light has red name. */
161 RED = 0x00000002,
162 /* The input light has green name. */
163 GREEN = 0x00000004,
164 /* The input light has blue name. */
165 BLUE = 0x00000008,
166 /* The input light has global name. */
167 GLOBAL = 0x00000010,
168 /* The input light has multi index node. */
169 MULTI_INDEX = 0x00000020,
170 /* The input light has multi intensity node. */
171 MULTI_INTENSITY = 0x00000040,
172 /* The input light has max brightness node. */
173 MAX_BRIGHTNESS = 0x00000080,
174};
175
Chris Yee2b1e5c2021-03-10 22:45:12 -0800176enum class InputBatteryClass : uint32_t {
177 /* The input device battery has capacity node. */
178 CAPACITY = 0x00000001,
179 /* The input device battery has capacity_level node. */
180 CAPACITY_LEVEL = 0x00000002,
181 /* The input device battery has status node. */
182 STATUS = 0x00000004,
183};
184
Chris Ye3fdbfef2021-01-06 18:45:18 -0800185/* Describes a raw light. */
186struct RawLightInfo {
187 int32_t id;
188 std::string name;
189 std::optional<int32_t> maxBrightness;
190 Flags<InputLightClass> flags;
191 std::array<int32_t, COLOR_NUM> rgbIndex;
192 std::filesystem::path path;
193};
194
Chris Yee2b1e5c2021-03-10 22:45:12 -0800195/* Describes a raw battery. */
196struct RawBatteryInfo {
197 int32_t id;
198 std::string name;
199 Flags<InputBatteryClass> flags;
200 std::filesystem::path path;
201};
202
Michael Wrightd02c5b62014-02-10 15:10:22 -0800203/*
204 * Gets the class that owns an axis, in cases where multiple classes might claim
205 * the same axis for different purposes.
206 */
Chris Ye1b0c7342020-07-28 21:57:03 -0700207extern Flags<InputDeviceClass> getAbsAxisUsage(int32_t axis, Flags<InputDeviceClass> deviceClasses);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800208
209/*
210 * Grand Central Station for events.
211 *
212 * The event hub aggregates input events received across all known input
213 * devices on the system, including devices that may be emulated by the simulator
214 * environment. In addition, the event hub generates fake input events to indicate
215 * when devices are added or removed.
216 *
217 * The event hub provides a stream of input events (via the getEvent function).
218 * It also supports querying the current actual state of input devices such as identifying
219 * which keys are currently down. Finally, the event hub keeps track of the capabilities of
220 * individual input devices, such as their class and the set of key codes that they support.
221 */
Siarhei Vishniakou3bc7e092019-07-24 17:43:30 -0700222class EventHubInterface {
223public:
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700224 EventHubInterface() {}
225 virtual ~EventHubInterface() {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800226
Michael Wrightd02c5b62014-02-10 15:10:22 -0800227 // Synthetic raw event type codes produced when devices are added or removed.
228 enum {
229 // Sent when a device is added.
230 DEVICE_ADDED = 0x10000000,
231 // Sent when a device is removed.
232 DEVICE_REMOVED = 0x20000000,
233 // Sent when all added/removed devices from the most recent scan have been reported.
234 // This event is always sent at least once.
235 FINISHED_DEVICE_SCAN = 0x30000000,
236
237 FIRST_SYNTHETIC_EVENT = DEVICE_ADDED,
238 };
239
Chris Ye1b0c7342020-07-28 21:57:03 -0700240 virtual Flags<InputDeviceClass> getDeviceClasses(int32_t deviceId) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800241
242 virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const = 0;
243
244 virtual int32_t getDeviceControllerNumber(int32_t deviceId) const = 0;
245
246 virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const = 0;
247
248 virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700249 RawAbsoluteAxisInfo* outAxisInfo) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800250
251 virtual bool hasRelativeAxis(int32_t deviceId, int axis) const = 0;
252
253 virtual bool hasInputProperty(int32_t deviceId, int property) const = 0;
254
Chris Yef59a2f42020-10-16 12:55:26 -0700255 virtual bool hasMscEvent(int32_t deviceId, int mscEvent) const = 0;
256
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700257 virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
258 int32_t metaState, int32_t* outKeycode, int32_t* outMetaState,
259 uint32_t* outFlags) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800260
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700261 virtual status_t mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800262
263 // Sets devices that are excluded from opening.
264 // This can be used to ignore input devices for sensors.
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100265 virtual void setExcludedDevices(const std::vector<std::string>& devices) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800266
267 /*
268 * Wait for events to become available and returns them.
269 * After returning, the EventHub holds onto a wake lock until the next call to getEvent.
270 * This ensures that the device will not go to sleep while the event is being processed.
271 * If the device needs to remain awake longer than that, then the caller is responsible
272 * for taking care of it (say, by poking the power manager user activity timer).
273 *
274 * The timeout is advisory only. If the device is asleep, it will not wake just to
275 * service the timeout.
276 *
277 * Returns the number of events obtained, or 0 if the timeout expired.
278 */
279 virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) = 0;
Siarhei Vishniakouadd89292018-12-13 19:23:36 -0800280 virtual std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) = 0;
Chris Yef59a2f42020-10-16 12:55:26 -0700281 virtual base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t deviceId,
282 int32_t absCode) = 0;
Chris Yee2b1e5c2021-03-10 22:45:12 -0800283 // Raw batteries are sysfs power_supply nodes we found from the EventHub device sysfs node,
284 // containing the raw info of the sysfs node structure.
285 virtual const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) = 0;
286 virtual std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,
287 int32_t BatteryId) = 0;
288
Chris Ye3fdbfef2021-01-06 18:45:18 -0800289 // Raw lights are sysfs led light nodes we found from the EventHub device sysfs node,
290 // containing the raw info of the sysfs node structure.
291 virtual const std::vector<int32_t> getRawLightIds(int32_t deviceId) = 0;
292 virtual std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) = 0;
293 virtual std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) = 0;
294 virtual void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) = 0;
295 virtual std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
296 int32_t deviceId, int32_t lightId) = 0;
297 virtual void setLightIntensities(int32_t deviceId, int32_t lightId,
298 std::unordered_map<LightColor, int32_t> intensities) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800299 /*
300 * Query current input state.
301 */
302 virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const = 0;
303 virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const = 0;
304 virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const = 0;
305 virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700306 int32_t* outValue) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800307
308 /*
309 * Examine key input devices for specific framework keycode support
310 */
311 virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700312 uint8_t* outFlags) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800313
314 virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const = 0;
315
316 /* LED related functions expect Android LED constants, not scan codes or HID usages */
317 virtual bool hasLed(int32_t deviceId, int32_t led) const = 0;
318 virtual void setLedState(int32_t deviceId, int32_t led, bool on) = 0;
319
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700320 virtual void getVirtualKeyDefinitions(
321 int32_t deviceId, std::vector<VirtualKeyDefinition>& outVirtualKeys) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800322
Chris Ye3a1e4462020-08-12 10:13:15 -0700323 virtual const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const = 0;
324 virtual bool setKeyboardLayoutOverlay(int32_t deviceId,
325 std::shared_ptr<KeyCharacterMap> map) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800326
327 /* Control the vibrator. */
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +0000328 virtual void vibrate(int32_t deviceId, const VibrationElement& effect) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800329 virtual void cancelVibrate(int32_t deviceId) = 0;
Chris Ye87143712020-11-10 05:05:58 +0000330 virtual std::vector<int32_t> getVibratorIds(int32_t deviceId) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800331
Kim Low03ea0352020-11-06 12:45:07 -0800332 /* Query battery level. */
Chris Yee2b1e5c2021-03-10 22:45:12 -0800333 virtual std::optional<int32_t> getBatteryCapacity(int32_t deviceId,
334 int32_t batteryId) const = 0;
Kim Low03ea0352020-11-06 12:45:07 -0800335
336 /* Query battery status. */
Chris Yee2b1e5c2021-03-10 22:45:12 -0800337 virtual std::optional<int32_t> getBatteryStatus(int32_t deviceId, int32_t batteryId) const = 0;
Kim Low03ea0352020-11-06 12:45:07 -0800338
Michael Wrightd02c5b62014-02-10 15:10:22 -0800339 /* Requests the EventHub to reopen all input devices on the next call to getEvents(). */
340 virtual void requestReopenDevices() = 0;
341
342 /* Wakes up getEvents() if it is blocked on a read. */
343 virtual void wake() = 0;
344
345 /* Dump EventHub state to a string. */
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800346 virtual void dump(std::string& dump) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800347
348 /* Called by the heatbeat to ensures that the reader has not deadlocked. */
349 virtual void monitor() = 0;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700350
351 /* Return true if the device is enabled. */
352 virtual bool isDeviceEnabled(int32_t deviceId) = 0;
353
354 /* Enable an input device */
355 virtual status_t enableDevice(int32_t deviceId) = 0;
356
357 /* Disable an input device. Closes file descriptor to that device. */
358 virtual status_t disableDevice(int32_t deviceId) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800359};
360
Chris Ye66fbac32020-07-06 20:36:43 -0700361template <std::size_t BITS>
362class BitArray {
363 /* Array element type and vector of element type. */
364 using Element = std::uint32_t;
365 /* Number of bits in each BitArray element. */
366 static constexpr size_t WIDTH = sizeof(Element) * CHAR_BIT;
367 /* Number of elements to represent a bit array of the specified size of bits. */
368 static constexpr size_t COUNT = (BITS + WIDTH - 1) / WIDTH;
369
370public:
371 /* BUFFER type declaration for BitArray */
372 using Buffer = std::array<Element, COUNT>;
373 /* To tell if a bit is set in array, it selects an element from the array, and test
374 * if the relevant bit set.
375 * Note the parameter "bit" is an index to the bit, 0 <= bit < BITS.
376 */
377 inline bool test(size_t bit) const {
378 return (bit < BITS) ? mData[bit / WIDTH].test(bit % WIDTH) : false;
379 }
380 /* Returns total number of bytes needed for the array */
381 inline size_t bytes() { return (BITS + CHAR_BIT - 1) / CHAR_BIT; }
382 /* Returns true if array contains any non-zero bit from the range defined by start and end
383 * bit index [startIndex, endIndex).
384 */
385 bool any(size_t startIndex, size_t endIndex) {
386 if (startIndex >= endIndex || startIndex > BITS || endIndex > BITS + 1) {
387 ALOGE("Invalid start/end index. start = %zu, end = %zu, total bits = %zu", startIndex,
388 endIndex, BITS);
389 return false;
390 }
391 size_t se = startIndex / WIDTH; // Start of element
392 size_t ee = endIndex / WIDTH; // End of element
393 size_t si = startIndex % WIDTH; // Start index in start element
394 size_t ei = endIndex % WIDTH; // End index in end element
395 // Need to check first unaligned bitset for any non zero bit
396 if (si > 0) {
397 size_t nBits = se == ee ? ei - si : WIDTH - si;
398 // Generate the mask of interested bit range
399 Element mask = ((1 << nBits) - 1) << si;
400 if (mData[se++].to_ulong() & mask) {
401 return true;
402 }
403 }
404 // Check whole bitset for any bit set
405 for (; se < ee; se++) {
406 if (mData[se].any()) {
407 return true;
408 }
409 }
410 // Need to check last unaligned bitset for any non zero bit
411 if (ei > 0 && se <= ee) {
412 // Generate the mask of interested bit range
413 Element mask = (1 << ei) - 1;
414 if (mData[se].to_ulong() & mask) {
415 return true;
416 }
417 }
418 return false;
419 }
420 /* Load bit array values from buffer */
421 void loadFromBuffer(const Buffer& buffer) {
422 for (size_t i = 0; i < COUNT; i++) {
423 mData[i] = std::bitset<WIDTH>(buffer[i]);
424 }
425 }
426
427private:
428 std::array<std::bitset<WIDTH>, COUNT> mData;
429};
430
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700431class EventHub : public EventHubInterface {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800432public:
433 EventHub();
434
Chris Ye989bb932020-07-04 16:18:59 -0700435 Flags<InputDeviceClass> getDeviceClasses(int32_t deviceId) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800436
Chris Ye989bb932020-07-04 16:18:59 -0700437 InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800438
Chris Ye989bb932020-07-04 16:18:59 -0700439 int32_t getDeviceControllerNumber(int32_t deviceId) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800440
Chris Ye989bb932020-07-04 16:18:59 -0700441 void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800442
Chris Ye989bb932020-07-04 16:18:59 -0700443 status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
444 RawAbsoluteAxisInfo* outAxisInfo) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800445
Chris Ye989bb932020-07-04 16:18:59 -0700446 bool hasRelativeAxis(int32_t deviceId, int axis) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800447
Chris Ye989bb932020-07-04 16:18:59 -0700448 bool hasInputProperty(int32_t deviceId, int property) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800449
Chris Yef59a2f42020-10-16 12:55:26 -0700450 bool hasMscEvent(int32_t deviceId, int mscEvent) const override final;
451
Chris Ye989bb932020-07-04 16:18:59 -0700452 status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
453 int32_t* outKeycode, int32_t* outMetaState,
454 uint32_t* outFlags) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800455
Chris Ye989bb932020-07-04 16:18:59 -0700456 status_t mapAxis(int32_t deviceId, int32_t scanCode,
457 AxisInfo* outAxisInfo) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800458
Chris Yef59a2f42020-10-16 12:55:26 -0700459 base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(
460 int32_t deviceId, int32_t absCode) override final;
461
Chris Yee2b1e5c2021-03-10 22:45:12 -0800462 const std::vector<int32_t> getRawBatteryIds(int32_t deviceId) override final;
463 std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,
464 int32_t BatteryId) override final;
465
Chris Ye3fdbfef2021-01-06 18:45:18 -0800466 const std::vector<int32_t> getRawLightIds(int32_t deviceId) override final;
467
468 std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) override final;
469
470 std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) override final;
471 void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) override final;
472 std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
473 int32_t deviceId, int32_t lightId) override final;
474 void setLightIntensities(int32_t deviceId, int32_t lightId,
475 std::unordered_map<LightColor, int32_t> intensities) override final;
476
Chris Ye989bb932020-07-04 16:18:59 -0700477 void setExcludedDevices(const std::vector<std::string>& devices) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800478
Chris Ye989bb932020-07-04 16:18:59 -0700479 int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const override final;
480 int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const override final;
481 int32_t getSwitchState(int32_t deviceId, int32_t sw) const override final;
482 status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
483 int32_t* outValue) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800484
Chris Ye989bb932020-07-04 16:18:59 -0700485 bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
486 uint8_t* outFlags) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800487
Chris Ye989bb932020-07-04 16:18:59 -0700488 size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) override final;
489 std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800490
Chris Ye989bb932020-07-04 16:18:59 -0700491 bool hasScanCode(int32_t deviceId, int32_t scanCode) const override final;
492 bool hasLed(int32_t deviceId, int32_t led) const override final;
493 void setLedState(int32_t deviceId, int32_t led, bool on) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800494
Chris Ye989bb932020-07-04 16:18:59 -0700495 void getVirtualKeyDefinitions(
496 int32_t deviceId,
497 std::vector<VirtualKeyDefinition>& outVirtualKeys) const override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800498
Chris Ye3a1e4462020-08-12 10:13:15 -0700499 const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap(
500 int32_t deviceId) const override final;
501 bool setKeyboardLayoutOverlay(int32_t deviceId,
502 std::shared_ptr<KeyCharacterMap> map) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800503
Chris Ye989bb932020-07-04 16:18:59 -0700504 void vibrate(int32_t deviceId, const VibrationElement& effect) override final;
505 void cancelVibrate(int32_t deviceId) override final;
Chris Ye87143712020-11-10 05:05:58 +0000506 std::vector<int32_t> getVibratorIds(int32_t deviceId) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800507
Chris Ye989bb932020-07-04 16:18:59 -0700508 void requestReopenDevices() override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800509
Chris Ye989bb932020-07-04 16:18:59 -0700510 void wake() override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800511
Chris Ye989bb932020-07-04 16:18:59 -0700512 void dump(std::string& dump) override final;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800513
Chris Ye989bb932020-07-04 16:18:59 -0700514 void monitor() override final;
515
Chris Yee2b1e5c2021-03-10 22:45:12 -0800516 std::optional<int32_t> getBatteryCapacity(int32_t deviceId,
517 int32_t batteryId) const override final;
Kim Low03ea0352020-11-06 12:45:07 -0800518
Chris Yee2b1e5c2021-03-10 22:45:12 -0800519 std::optional<int32_t> getBatteryStatus(int32_t deviceId,
520 int32_t batteryId) const override final;
Kim Low03ea0352020-11-06 12:45:07 -0800521
Chris Ye989bb932020-07-04 16:18:59 -0700522 bool isDeviceEnabled(int32_t deviceId) override final;
523
524 status_t enableDevice(int32_t deviceId) override final;
525
526 status_t disableDevice(int32_t deviceId) override final;
527
528 ~EventHub() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800529
530private:
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700531 struct AssociatedDevice {
Chris Yee2b1e5c2021-03-10 22:45:12 -0800532 // The device descriptor from evdev device the misc device associated with.
533 std::string descriptor;
534 // The sysfs root path of the misc device.
535 std::filesystem::path sysfsRootPath;
536
537 int32_t nextBatteryId;
538 int32_t nextLightId;
539 std::unordered_map<int32_t, RawBatteryInfo> batteryInfos;
540 std::unordered_map<int32_t, RawLightInfo> lightInfos;
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700541 explicit AssociatedDevice(std::filesystem::path sysfsRootPath)
Chris Yee2b1e5c2021-03-10 22:45:12 -0800542 : sysfsRootPath(sysfsRootPath), nextBatteryId(0), nextLightId(0) {}
543 bool configureBatteryLocked();
544 bool configureLightsLocked();
545 };
546
Michael Wrightd02c5b62014-02-10 15:10:22 -0800547 struct Device {
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700548 int fd; // may be -1 if device is closed
Michael Wrightd02c5b62014-02-10 15:10:22 -0800549 const int32_t id;
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100550 const std::string path;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800551 const InputDeviceIdentifier identifier;
552
Siarhei Vishniakouec7854a2018-12-14 16:52:34 -0800553 std::unique_ptr<TouchVideoDevice> videoDevice;
554
Chris Ye1b0c7342020-07-28 21:57:03 -0700555 Flags<InputDeviceClass> classes;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800556
Chris Ye66fbac32020-07-06 20:36:43 -0700557 BitArray<KEY_MAX> keyBitmask;
558 BitArray<KEY_MAX> keyState;
559 BitArray<ABS_MAX> absBitmask;
560 BitArray<REL_MAX> relBitmask;
561 BitArray<SW_MAX> swBitmask;
562 BitArray<SW_MAX> swState;
563 BitArray<LED_MAX> ledBitmask;
564 BitArray<FF_MAX> ffBitmask;
565 BitArray<INPUT_PROP_MAX> propBitmask;
Chris Yef59a2f42020-10-16 12:55:26 -0700566 BitArray<MSC_MAX> mscBitmask;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800567
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100568 std::string configurationFile;
Siarhei Vishniakoud549b252020-08-11 11:25:26 -0500569 std::unique_ptr<PropertyMap> configuration;
Siarhei Vishniakou3e78dec2019-02-20 16:21:46 -0600570 std::unique_ptr<VirtualKeyMap> virtualKeyMap;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800571 KeyMap keyMap;
572
Michael Wrightd02c5b62014-02-10 15:10:22 -0800573 bool ffEffectPlaying;
574 int16_t ffEffectId; // initially -1
575
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700576 // A shared_ptr of a device associated with the input device.
577 // The input devices with same descriptor has the same associated device.
578 std::shared_ptr<AssociatedDevice> associatedDevice;
Kim Low03ea0352020-11-06 12:45:07 -0800579
Michael Wrightd02c5b62014-02-10 15:10:22 -0800580 int32_t controllerNumber;
581
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100582 Device(int fd, int32_t id, const std::string& path,
Prabir Pradhanda7c00c2019-08-29 14:12:42 -0700583 const InputDeviceIdentifier& identifier);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800584 ~Device();
585
586 void close();
587
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700588 bool enabled; // initially true
589 status_t enable();
590 status_t disable();
Chris Ye989bb932020-07-04 16:18:59 -0700591 bool hasValidFd() const;
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700592 const bool isVirtual; // set if fd < 0 is passed to constructor
Michael Wrightd02c5b62014-02-10 15:10:22 -0800593
Chris Ye3a1e4462020-08-12 10:13:15 -0700594 const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap() const;
Chris Ye66fbac32020-07-06 20:36:43 -0700595
596 template <std::size_t N>
Chris Ye989bb932020-07-04 16:18:59 -0700597 status_t readDeviceBitMask(unsigned long ioctlCode, BitArray<N>& bitArray);
Chris Ye66fbac32020-07-06 20:36:43 -0700598
Chris Ye989bb932020-07-04 16:18:59 -0700599 void configureFd();
600 bool hasKeycodeLocked(int keycode) const;
601 void loadConfigurationLocked();
602 bool loadVirtualKeyMapLocked();
603 status_t loadKeyMapLocked();
604 bool isExternalDeviceLocked();
605 bool deviceHasMicLocked();
606 void setLedForControllerLocked();
607 status_t mapLed(int32_t led, int32_t* outScanCode) const;
608 void setLedStateLocked(int32_t led, bool on);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800609 };
610
Siarhei Vishniakoua4c502a2021-02-05 00:45:20 +0000611 /**
612 * Create a new device for the provided path.
613 */
Chris Yed3fef462021-03-07 17:10:08 -0800614 void openDeviceLocked(const std::string& devicePath) REQUIRES(mLock);
615 void openVideoDeviceLocked(const std::string& devicePath) REQUIRES(mLock);
Siarhei Vishniakouf49608d2020-08-20 19:18:21 -0500616 /**
617 * Try to associate a video device with an input device. If the association succeeds,
618 * the videoDevice is moved into the input device. 'videoDevice' will become null if this
619 * happens.
620 * Return true if the association succeeds.
621 * Return false otherwise.
622 */
Chris Yed3fef462021-03-07 17:10:08 -0800623 bool tryAddVideoDeviceLocked(Device& device, std::unique_ptr<TouchVideoDevice>& videoDevice)
624 REQUIRES(mLock);
625 void createVirtualKeyboardLocked() REQUIRES(mLock);
626 void addDeviceLocked(std::unique_ptr<Device> device) REQUIRES(mLock);
627 void assignDescriptorLocked(InputDeviceIdentifier& identifier) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800628
Chris Yed3fef462021-03-07 17:10:08 -0800629 void closeDeviceByPathLocked(const std::string& devicePath) REQUIRES(mLock);
630 void closeVideoDeviceByPathLocked(const std::string& devicePath) REQUIRES(mLock);
631 void closeDeviceLocked(Device& device) REQUIRES(mLock);
632 void closeAllDevicesLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800633
Siarhei Vishniakou25920312018-12-12 15:24:44 -0800634 status_t registerFdForEpoll(int fd);
635 status_t unregisterFdFromEpoll(int fd);
Chris Yed3fef462021-03-07 17:10:08 -0800636 status_t registerDeviceForEpollLocked(Device& device) REQUIRES(mLock);
637 void registerVideoDeviceForEpollLocked(const TouchVideoDevice& videoDevice) REQUIRES(mLock);
638 status_t unregisterDeviceFromEpollLocked(Device& device) REQUIRES(mLock);
639 void unregisterVideoDeviceFromEpollLocked(const TouchVideoDevice& videoDevice) REQUIRES(mLock);
Siarhei Vishniakoue54cb852017-03-21 17:48:16 -0700640
Chris Yed3fef462021-03-07 17:10:08 -0800641 status_t scanDirLocked(const std::string& dirname) REQUIRES(mLock);
642 status_t scanVideoDirLocked(const std::string& dirname) REQUIRES(mLock);
643 void scanDevicesLocked() REQUIRES(mLock);
644 status_t readNotifyLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800645
Chris Yed3fef462021-03-07 17:10:08 -0800646 Device* getDeviceByDescriptorLocked(const std::string& descriptor) const REQUIRES(mLock);
647 Device* getDeviceLocked(int32_t deviceId) const REQUIRES(mLock);
648 Device* getDeviceByPathLocked(const std::string& devicePath) const REQUIRES(mLock);
Siarhei Vishniakou12598682018-11-02 17:19:19 -0700649 /**
650 * Look through all available fd's (both for input devices and for video devices),
651 * and return the device pointer.
652 */
Chris Yed3fef462021-03-07 17:10:08 -0800653 Device* getDeviceByFdLocked(int fd) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800654
Chris Yed3fef462021-03-07 17:10:08 -0800655 int32_t getNextControllerNumberLocked(const std::string& name) REQUIRES(mLock);
656 void releaseControllerNumberLocked(int32_t num) REQUIRES(mLock);
657 void reportDeviceAddedForStatisticsLocked(const InputDeviceIdentifier& identifier,
658 Flags<InputDeviceClass> classes) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800659
Chris Yee2b1e5c2021-03-10 22:45:12 -0800660 const std::unordered_map<int32_t, RawBatteryInfo>& getBatteryInfoLocked(int32_t deviceId) const
661 REQUIRES(mLock);
662
663 const std::unordered_map<int32_t, RawLightInfo>& getLightInfoLocked(int32_t deviceId) const
664 REQUIRES(mLock);
665
Michael Wrightd02c5b62014-02-10 15:10:22 -0800666 // Protect all internal state.
Chris Ye1c2e0892020-11-30 21:41:44 -0800667 mutable std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800668
669 // The actual id of the built-in keyboard, or NO_BUILT_IN_KEYBOARD if none.
670 // EventHub remaps the built-in keyboard to id 0 externally as required by the API.
671 enum {
672 // Must not conflict with any other assigned device ids, including
673 // the virtual keyboard id (-1).
674 NO_BUILT_IN_KEYBOARD = -2,
675 };
676 int32_t mBuiltInKeyboardId;
677
678 int32_t mNextDeviceId;
679
680 BitSet32 mControllerNumbers;
681
Chris Ye989bb932020-07-04 16:18:59 -0700682 std::unordered_map<int32_t, std::unique_ptr<Device>> mDevices;
Siarhei Vishniakou22c88462018-12-13 19:34:53 -0800683 /**
684 * Video devices that report touchscreen heatmap, but have not (yet) been paired
685 * with a specific input device. Video device discovery is independent from input device
686 * discovery, so the two types of devices could be found in any order.
687 * Ideally, video devices in this queue do not have an open fd, or at least aren't
688 * actively streaming.
689 */
690 std::vector<std::unique_ptr<TouchVideoDevice>> mUnattachedVideoDevices;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800691
Chris Ye989bb932020-07-04 16:18:59 -0700692 std::vector<std::unique_ptr<Device>> mOpeningDevices;
693 std::vector<std::unique_ptr<Device>> mClosingDevices;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800694
695 bool mNeedToSendFinishedDeviceScan;
696 bool mNeedToReopenDevices;
697 bool mNeedToScanDevices;
Siarhei Vishniakouec8f7252018-07-06 11:19:32 +0100698 std::vector<std::string> mExcludedDevices;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800699
700 int mEpollFd;
701 int mINotifyFd;
702 int mWakeReadPipeFd;
703 int mWakeWritePipeFd;
704
Siarhei Vishniakou951f3622018-12-12 19:45:42 -0800705 int mInputWd;
706 int mVideoWd;
707
Michael Wrightd02c5b62014-02-10 15:10:22 -0800708 // Maximum number of signalled FDs to handle at a time.
709 static const int EPOLL_MAX_EVENTS = 16;
710
711 // The array of pending epoll events and the index of the next event to be handled.
712 struct epoll_event mPendingEventItems[EPOLL_MAX_EVENTS];
713 size_t mPendingEventCount;
714 size_t mPendingEventIndex;
715 bool mPendingINotify;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800716};
717
718}; // namespace android
719
720#endif // _RUNTIME_EVENT_HUB_H