blob: 2a7e262bf53f7856e3eab6fbce0e5e0c2915a024 [file] [log] [blame]
Prabir Pradhanbaa5c822019-08-30 15:27:05 -07001/*
2 * Copyright (C) 2019 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
Prabir Pradhan48108662022-09-09 21:22:04 +000017#pragma once
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070018
Dominik Laskowski2f01d772022-03-23 16:01:29 -070019#include <ftl/flags.h>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080020#include <input/DisplayViewport.h>
21#include <input/InputDevice.h>
Siarhei Vishniakou32f36ae2020-09-02 20:17:10 -070022#include <input/PropertyMap.h>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080023
Dominik Laskowski2f01d772022-03-23 16:01:29 -070024#include <cstdint>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080025#include <optional>
26#include <unordered_map>
27#include <vector>
28
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070029#include "EventHub.h"
30#include "InputReaderBase.h"
31#include "InputReaderContext.h"
Siarhei Vishniakou2935db72022-09-22 13:35:22 -070032#include "NotifyArgs.h"
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070033
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070034namespace android {
35
Chris Ye1dd2e5c2021-04-04 23:12:41 -070036class PeripheralController;
37class PeripheralControllerInterface;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -080038class InputDeviceContext;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070039class InputMapper;
40
41/* Represents the state of a single input device. */
42class InputDevice {
43public:
44 InputDevice(InputReaderContext* context, int32_t id, int32_t generation,
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080045 const InputDeviceIdentifier& identifier);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070046 ~InputDevice();
47
48 inline InputReaderContext* getContext() { return mContext; }
49 inline int32_t getId() const { return mId; }
50 inline int32_t getControllerNumber() const { return mControllerNumber; }
51 inline int32_t getGeneration() const { return mGeneration; }
52 inline const std::string getName() const { return mIdentifier.name; }
53 inline const std::string getDescriptor() { return mIdentifier.descriptor; }
Prabir Pradhanb54ffb22022-10-27 18:03:34 +000054 inline std::optional<std::string> getBluetoothAddress() const {
55 return mIdentifier.bluetoothAddress;
56 }
Zixuan Qufecb6062022-11-12 04:44:31 +000057 inline const std::string getLocation() const { return mIdentifier.location; }
Dominik Laskowski2f01d772022-03-23 16:01:29 -070058 inline ftl::Flags<InputDeviceClass> getClasses() const { return mClasses; }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070059 inline uint32_t getSources() const { return mSources; }
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080060 inline bool hasEventHubDevices() const { return !mDevices.empty(); }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070061
62 inline bool isExternal() { return mIsExternal; }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070063 inline std::optional<uint8_t> getAssociatedDisplayPort() const {
64 return mAssociatedDisplayPort;
65 }
Antonio Kantek0ac5e092024-04-22 17:10:27 +000066 inline std::optional<std::string> getAssociatedDisplayUniqueIdByPort() const {
67 return mAssociatedDisplayUniqueIdByPort;
68 }
69 inline std::optional<std::string> getAssociatedDisplayUniqueIdByDescriptor() const {
70 return mAssociatedDisplayUniqueIdByDescriptor;
Christine Franks2a2293c2022-01-18 11:51:16 -080071 }
Ambrus Weisz7bc23bf2022-10-04 13:13:07 +000072 inline std::optional<std::string> getDeviceTypeAssociation() const {
73 return mAssociatedDeviceType;
74 }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070075 inline std::optional<DisplayViewport> getAssociatedViewport() const {
76 return mAssociatedViewport;
77 }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070078 inline bool hasMic() const { return mHasMic; }
79
Vaibhav Devmurari16c24192023-05-04 15:20:12 +000080 inline bool isIgnored() { return !getMapperCount() && !mController; }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070081
Vaibhav Devmurarie58ffb92024-05-22 17:38:25 +000082 inline KeyboardType getKeyboardType() const { return mKeyboardType; }
83
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070084 bool isEnabled();
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070085
Chris Yee7310032020-09-22 15:36:28 -070086 void dump(std::string& dump, const std::string& eventHubDevStr);
Arpit Singh8e6fb252023-04-06 11:49:17 +000087 void addEmptyEventHubDevice(int32_t eventHubId);
Arpit Singh82f29a12023-06-13 15:05:53 +000088 [[nodiscard]] std::list<NotifyArgs> addEventHubDevice(
89 nsecs_t when, int32_t eventHubId, const InputReaderConfiguration& readerConfig);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080090 void removeEventHubDevice(int32_t eventHubId);
Siarhei Vishniakou2935db72022-09-22 13:35:22 -070091 [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when,
Arpit Singhed6c3de2023-04-05 19:24:37 +000092 const InputReaderConfiguration& readerConfig,
Arpit Singh7f1765e2023-07-07 13:12:37 +000093 ConfigurationChanges changes);
Siarhei Vishniakou2935db72022-09-22 13:35:22 -070094 [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when);
95 [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvents, size_t count);
96 [[nodiscard]] std::list<NotifyArgs> timeoutExpired(nsecs_t when);
97 [[nodiscard]] std::list<NotifyArgs> updateExternalStylusState(const StylusState& state);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070098
Siarhei Vishniakou1983a712021-06-04 19:27:09 +000099 InputDeviceInfo getDeviceInfo();
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700100 int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
101 int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
102 int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
Philip Junker4af3b3d2021-12-14 10:36:55 +0100103 int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const;
Siarhei Vishniakou74007942022-06-13 13:57:47 -0700104 bool markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes,
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700105 uint8_t* outFlags);
Siarhei Vishniakou2935db72022-09-22 13:35:22 -0700106 [[nodiscard]] std::list<NotifyArgs> vibrate(const VibrationSequence& sequence, ssize_t repeat,
107 int32_t token);
108 [[nodiscard]] std::list<NotifyArgs> cancelVibrate(int32_t token);
Chris Ye87143712020-11-10 05:05:58 +0000109 bool isVibrating();
110 std::vector<int32_t> getVibratorIds();
Siarhei Vishniakou2935db72022-09-22 13:35:22 -0700111 [[nodiscard]] std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime);
Chris Yef59a2f42020-10-16 12:55:26 -0700112 bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod,
113 std::chrono::microseconds maxBatchReportLatency);
114 void disableSensor(InputDeviceSensorType sensorType);
115 void flushSensor(InputDeviceSensorType sensorType);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700116
Andy Chenf9f1a022022-08-29 20:07:10 -0400117 std::optional<int32_t> getBatteryEventHubId() const;
Kim Low03ea0352020-11-06 12:45:07 -0800118
Chris Ye3fdbfef2021-01-06 18:45:18 -0800119 bool setLightColor(int32_t lightId, int32_t color);
120 bool setLightPlayerId(int32_t lightId, int32_t playerId);
121 std::optional<int32_t> getLightColor(int32_t lightId);
122 std::optional<int32_t> getLightPlayerId(int32_t lightId);
123
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700124 int32_t getMetaState();
125 void updateMetaState(int32_t keyCode);
126
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +0000127 void addKeyRemapping(int32_t fromKeyCode, int32_t toKeyCode);
128
Vaibhav Devmurarie58ffb92024-05-22 17:38:25 +0000129 void setKeyboardType(KeyboardType keyboardType);
130
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700131 void bumpGeneration();
132
Siarhei Vishniakou2935db72022-09-22 13:35:22 -0700133 [[nodiscard]] NotifyDeviceResetArgs notifyReset(nsecs_t when);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700134
135 inline const PropertyMap& getConfiguration() { return mConfiguration; }
136 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
137
Linnan Li13bf76a2024-05-05 19:18:02 +0800138 std::optional<ui::LogicalDisplayId> getAssociatedDisplayId();
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700139
arthurhungc903df12020-08-11 15:08:42 +0800140 void updateLedState(bool reset);
141
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800142 size_t getMapperCount();
143
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800144 // construct and add a mapper to the input device
145 template <class T, typename... Args>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800146 T& addMapper(int32_t eventHubId, Args... args) {
147 // ensure a device entry exists for this eventHubId
Arpit Singh8e6fb252023-04-06 11:49:17 +0000148 addEmptyEventHubDevice(eventHubId);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800149
150 // create mapper
151 auto& devicePair = mDevices[eventHubId];
152 auto& deviceContext = devicePair.first;
153 auto& mappers = devicePair.second;
154 T* mapper = new T(*deviceContext, args...);
155 mappers.emplace_back(mapper);
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800156 return *mapper;
157 }
158
Arpit Singh56adebc2023-04-25 13:56:05 +0000159 template <class T, typename... Args>
160 T& constructAndAddMapper(int32_t eventHubId, Args... args) {
161 // create mapper
162 auto& devicePair = mDevices[eventHubId];
163 auto& deviceContext = devicePair.first;
164 auto& mappers = devicePair.second;
165 mappers.push_back(createInputMapper<T>(*deviceContext, args...));
166 return static_cast<T&>(*mappers.back());
167 }
168
Chris Yee2b1e5c2021-03-10 22:45:12 -0800169 // construct and add a controller to the input device
170 template <class T>
171 T& addController(int32_t eventHubId) {
172 // ensure a device entry exists for this eventHubId
Arpit Singh8e6fb252023-04-06 11:49:17 +0000173 addEmptyEventHubDevice(eventHubId);
Chris Yee2b1e5c2021-03-10 22:45:12 -0800174
175 // create controller
176 auto& devicePair = mDevices[eventHubId];
177 auto& deviceContext = devicePair.first;
178
179 mController = std::make_unique<T>(*deviceContext);
180 return *(reinterpret_cast<T*>(mController.get()));
181 }
182
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700183private:
184 InputReaderContext* mContext;
185 int32_t mId;
186 int32_t mGeneration;
187 int32_t mControllerNumber;
188 InputDeviceIdentifier mIdentifier;
189 std::string mAlias;
Dominik Laskowski2f01d772022-03-23 16:01:29 -0700190 ftl::Flags<InputDeviceClass> mClasses;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700191
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800192 // map from eventHubId to device context and mappers
193 using MapperVector = std::vector<std::unique_ptr<InputMapper>>;
194 using DevicePair = std::pair<std::unique_ptr<InputDeviceContext>, MapperVector>;
Chris Yee2b1e5c2021-03-10 22:45:12 -0800195 // Map from EventHub ID to pair of device context and vector of mapper.
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800196 std::unordered_map<int32_t, DevicePair> mDevices;
Chris Yee2b1e5c2021-03-10 22:45:12 -0800197 // Misc devices controller for lights, battery, etc.
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700198 std::unique_ptr<PeripheralControllerInterface> mController;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700199
200 uint32_t mSources;
Yeabkal Wubshite03e8b12023-06-27 16:23:12 -0700201 bool mIsWaking;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700202 bool mIsExternal;
Vaibhav Devmurarie58ffb92024-05-22 17:38:25 +0000203 KeyboardType mKeyboardType = KeyboardType::NONE;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700204 std::optional<uint8_t> mAssociatedDisplayPort;
Antonio Kantek0ac5e092024-04-22 17:10:27 +0000205 std::optional<std::string> mAssociatedDisplayUniqueIdByPort;
206 std::optional<std::string> mAssociatedDisplayUniqueIdByDescriptor;
Ambrus Weisz7bc23bf2022-10-04 13:13:07 +0000207 std::optional<std::string> mAssociatedDeviceType;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700208 std::optional<DisplayViewport> mAssociatedViewport;
209 bool mHasMic;
210 bool mDropUntilNextSync;
Yeabkal Wubshitb1b96db2024-01-24 12:47:00 -0800211 std::optional<bool> mShouldSmoothScroll;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700212
213 typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);
214 int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);
215
Arpit Singh8e6fb252023-04-06 11:49:17 +0000216 std::vector<std::unique_ptr<InputMapper>> createMappers(
217 InputDeviceContext& contextPtr, const InputReaderConfiguration& readerConfig);
218
Arpit Singh82f29a12023-06-13 15:05:53 +0000219 [[nodiscard]] std::list<NotifyArgs> configureInternal(
220 nsecs_t when, const InputReaderConfiguration& readerConfig,
221 ConfigurationChanges changes, bool forceEnable = false);
222
Arpit Singh48189772023-05-30 14:12:49 +0000223 [[nodiscard]] std::list<NotifyArgs> updateEnableState(
Arpit Singh82f29a12023-06-13 15:05:53 +0000224 nsecs_t when, const InputReaderConfiguration& readerConfig, bool forceEnable = false);
Arpit Singh48189772023-05-30 14:12:49 +0000225
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700226 PropertyMap mConfiguration;
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800227
Yeabkal Wubshite03e8b12023-06-27 16:23:12 -0700228 // Runs logic post a `process` call. This can be used to update the generated `NotifyArgs` as
229 // per the properties of the InputDevice.
230 void postProcess(std::list<NotifyArgs>& args) const;
231
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800232 // helpers to interate over the devices collection
233 // run a function against every mapper on every subdevice
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800234 inline void for_each_mapper(std::function<void(InputMapper&)> f) {
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800235 for (auto& deviceEntry : mDevices) {
236 auto& devicePair = deviceEntry.second;
237 auto& mappers = devicePair.second;
238 for (auto& mapperPtr : mappers) {
239 f(*mapperPtr);
240 }
241 }
242 }
243
244 // run a function against every mapper on a specific subdevice
245 inline void for_each_mapper_in_subdevice(int32_t eventHubDevice,
246 std::function<void(InputMapper&)> f) {
247 auto deviceIt = mDevices.find(eventHubDevice);
248 if (deviceIt != mDevices.end()) {
249 auto& devicePair = deviceIt->second;
250 auto& mappers = devicePair.second;
251 for (auto& mapperPtr : mappers) {
252 f(*mapperPtr);
253 }
254 }
255 }
256
257 // run a function against every subdevice
258 inline void for_each_subdevice(std::function<void(InputDeviceContext&)> f) {
259 for (auto& deviceEntry : mDevices) {
260 auto& devicePair = deviceEntry.second;
261 auto& contextPtr = devicePair.first;
262 f(*contextPtr);
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800263 }
264 }
265
266 // return the first value returned by a function over every mapper.
267 // if all mappers return nullopt, return nullopt.
268 template <typename T>
Philip Junker4af3b3d2021-12-14 10:36:55 +0100269 inline std::optional<T> first_in_mappers(
270 std::function<std::optional<T>(InputMapper&)> f) const {
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800271 for (auto& deviceEntry : mDevices) {
272 auto& devicePair = deviceEntry.second;
273 auto& mappers = devicePair.second;
274 for (auto& mapperPtr : mappers) {
275 std::optional<T> ret = f(*mapperPtr);
276 if (ret) {
277 return ret;
278 }
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800279 }
280 }
281 return std::nullopt;
282 }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700283};
284
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800285/* Provides access to EventHub methods, but limits access to the current InputDevice.
286 * Essentially an implementation of EventHubInterface, but for a specific device id.
287 * Helps hide implementation details of InputDevice and EventHub. Used by mappers to
288 * check the status of the associated hardware device
289 */
290class InputDeviceContext {
291public:
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800292 InputDeviceContext(InputDevice& device, int32_t eventHubId);
Harry Cutts92559ef2024-01-05 12:45:36 +0000293 virtual ~InputDeviceContext();
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800294
295 inline InputReaderContext* getContext() { return mContext; }
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800296 inline int32_t getId() { return mDeviceId; }
297 inline int32_t getEventHubId() { return mId; }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800298
Dominik Laskowski2f01d772022-03-23 16:01:29 -0700299 inline ftl::Flags<InputDeviceClass> getDeviceClasses() const {
Chris Ye1b0c7342020-07-28 21:57:03 -0700300 return mEventHub->getDeviceClasses(mId);
301 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800302 inline InputDeviceIdentifier getDeviceIdentifier() const {
303 return mEventHub->getDeviceIdentifier(mId);
304 }
305 inline int32_t getDeviceControllerNumber() const {
306 return mEventHub->getDeviceControllerNumber(mId);
307 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800308 inline status_t getAbsoluteAxisInfo(int32_t code, RawAbsoluteAxisInfo* axisInfo) const {
Prabir Pradhan10301422023-07-26 21:48:30 +0000309 if (const auto status = mEventHub->getAbsoluteAxisInfo(mId, code, axisInfo); status != OK) {
310 return status;
311 }
312
313 // Validate axis info for InputDevice.
314 if (axisInfo->valid && axisInfo->minValue == axisInfo->maxValue) {
315 // Historically, we deem axes with the same min and max values as invalid to avoid
316 // dividing by zero when scaling by max - min.
317 // TODO(b/291772515): Perform axis info validation on a per-axis basis when it is used.
318 axisInfo->valid = false;
319 }
320 return OK;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800321 }
322 inline bool hasRelativeAxis(int32_t code) const {
323 return mEventHub->hasRelativeAxis(mId, code);
324 }
Chris Yef59a2f42020-10-16 12:55:26 -0700325 inline bool hasInputProperty(int32_t property) const {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800326 return mEventHub->hasInputProperty(mId, property);
327 }
Chris Yef59a2f42020-10-16 12:55:26 -0700328
329 inline bool hasMscEvent(int mscEvent) const { return mEventHub->hasMscEvent(mId, mscEvent); }
330
Vaibhav Devmuraricbba14c2022-10-10 16:54:49 +0000331 inline void addKeyRemapping(int32_t fromKeyCode, int32_t toKeyCode) const {
332 mEventHub->addKeyRemapping(mId, fromKeyCode, toKeyCode);
333 }
334
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800335 inline status_t mapKey(int32_t scanCode, int32_t usageCode, int32_t metaState,
336 int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
337 return mEventHub->mapKey(mId, scanCode, usageCode, metaState, outKeycode, outMetaState,
338 outFlags);
339 }
340 inline status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const {
341 return mEventHub->mapAxis(mId, scanCode, outAxisInfo);
342 }
Chris Yef59a2f42020-10-16 12:55:26 -0700343 inline base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode) {
344 return mEventHub->mapSensor(mId, absCode);
345 }
346
Chris Ye3fdbfef2021-01-06 18:45:18 -0800347 inline const std::vector<int32_t> getRawLightIds() { return mEventHub->getRawLightIds(mId); }
348
349 inline std::optional<RawLightInfo> getRawLightInfo(int32_t lightId) {
350 return mEventHub->getRawLightInfo(mId, lightId);
351 }
352
353 inline std::optional<int32_t> getLightBrightness(int32_t lightId) {
354 return mEventHub->getLightBrightness(mId, lightId);
355 }
356
357 inline void setLightBrightness(int32_t lightId, int32_t brightness) {
358 return mEventHub->setLightBrightness(mId, lightId, brightness);
359 }
360
361 inline std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
362 int32_t lightId) {
363 return mEventHub->getLightIntensities(mId, lightId);
364 }
365
366 inline void setLightIntensities(int32_t lightId,
367 std::unordered_map<LightColor, int32_t> intensities) {
368 return mEventHub->setLightIntensities(mId, lightId, intensities);
369 }
370
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800371 inline std::vector<TouchVideoFrame> getVideoFrames() { return mEventHub->getVideoFrames(mId); }
372 inline int32_t getScanCodeState(int32_t scanCode) const {
373 return mEventHub->getScanCodeState(mId, scanCode);
374 }
375 inline int32_t getKeyCodeState(int32_t keyCode) const {
376 return mEventHub->getKeyCodeState(mId, keyCode);
377 }
Philip Junker4af3b3d2021-12-14 10:36:55 +0100378 inline int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const {
379 return mEventHub->getKeyCodeForKeyLocation(mId, locationKeyCode);
380 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800381 inline int32_t getSwitchState(int32_t sw) const { return mEventHub->getSwitchState(mId, sw); }
382 inline status_t getAbsoluteAxisValue(int32_t code, int32_t* outValue) const {
383 return mEventHub->getAbsoluteAxisValue(mId, code, outValue);
384 }
Arpit Singh4b4a4572023-11-24 18:19:56 +0000385 inline base::Result<std::vector<int32_t>> getMtSlotValues(int32_t axis,
386 size_t slotCount) const {
387 return mEventHub->getMtSlotValues(mId, axis, slotCount);
388 }
Siarhei Vishniakou74007942022-06-13 13:57:47 -0700389 inline bool markSupportedKeyCodes(const std::vector<int32_t>& keyCodes,
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800390 uint8_t* outFlags) const {
Siarhei Vishniakou74007942022-06-13 13:57:47 -0700391 return mEventHub->markSupportedKeyCodes(mId, keyCodes, outFlags);
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800392 }
393 inline bool hasScanCode(int32_t scanCode) const {
394 return mEventHub->hasScanCode(mId, scanCode);
395 }
Arthur Hungcb40a002021-08-03 14:31:01 +0000396 inline bool hasKeyCode(int32_t keyCode) const { return mEventHub->hasKeyCode(mId, keyCode); }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800397 inline bool hasLed(int32_t led) const { return mEventHub->hasLed(mId, led); }
398 inline void setLedState(int32_t led, bool on) { return mEventHub->setLedState(mId, led, on); }
399 inline void getVirtualKeyDefinitions(std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
400 return mEventHub->getVirtualKeyDefinitions(mId, outVirtualKeys);
401 }
Chris Ye3a1e4462020-08-12 10:13:15 -0700402 inline const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap() const {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800403 return mEventHub->getKeyCharacterMap(mId);
404 }
Chris Ye3a1e4462020-08-12 10:13:15 -0700405 inline bool setKeyboardLayoutOverlay(std::shared_ptr<KeyCharacterMap> map) {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800406 return mEventHub->setKeyboardLayoutOverlay(mId, map);
407 }
Vaibhav Devmurari7fb41132023-01-02 13:30:26 +0000408 inline const std::optional<RawLayoutInfo> getRawLayoutInfo() {
409 return mEventHub->getRawLayoutInfo(mId);
410 }
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +0000411 inline void vibrate(const VibrationElement& element) {
412 return mEventHub->vibrate(mId, element);
413 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800414 inline void cancelVibrate() { return mEventHub->cancelVibrate(mId); }
415
Chris Ye87143712020-11-10 05:05:58 +0000416 inline std::vector<int32_t> getVibratorIds() { return mEventHub->getVibratorIds(mId); }
417
Chris Yee2b1e5c2021-03-10 22:45:12 -0800418 inline const std::vector<int32_t> getRawBatteryIds() {
419 return mEventHub->getRawBatteryIds(mId);
Kim Low03ea0352020-11-06 12:45:07 -0800420 }
421
Chris Yee2b1e5c2021-03-10 22:45:12 -0800422 inline std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t batteryId) {
423 return mEventHub->getRawBatteryInfo(mId, batteryId);
424 }
425
426 inline std::optional<int32_t> getBatteryCapacity(int32_t batteryId) {
427 return mEventHub->getBatteryCapacity(mId, batteryId);
428 }
429
430 inline std::optional<int32_t> getBatteryStatus(int32_t batteryId) {
431 return mEventHub->getBatteryStatus(mId, batteryId);
432 }
Kim Low03ea0352020-11-06 12:45:07 -0800433
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800434 inline bool hasAbsoluteAxis(int32_t code) const {
435 RawAbsoluteAxisInfo info;
436 mEventHub->getAbsoluteAxisInfo(mId, code, &info);
437 return info.valid;
438 }
Prabir Pradhan4f05b5f2022-10-11 21:24:07 +0000439 inline bool isKeyPressed(int32_t scanCode) const {
440 return mEventHub->getScanCodeState(mId, scanCode) == AKEY_STATE_DOWN;
441 }
442 inline bool isKeyCodePressed(int32_t keyCode) const {
443 return mEventHub->getKeyCodeState(mId, keyCode) == AKEY_STATE_DOWN;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800444 }
445 inline int32_t getAbsoluteAxisValue(int32_t code) const {
446 int32_t value;
447 mEventHub->getAbsoluteAxisValue(mId, code, &value);
448 return value;
449 }
450 inline bool isDeviceEnabled() { return mEventHub->isDeviceEnabled(mId); }
451 inline status_t enableDevice() { return mEventHub->enableDevice(mId); }
452 inline status_t disableDevice() { return mEventHub->disableDevice(mId); }
453
Harry Cuttsba9364a2022-12-15 12:39:04 +0000454 inline const std::string getName() const { return mDevice.getName(); }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800455 inline const std::string getDescriptor() { return mDevice.getDescriptor(); }
Zixuan Qufecb6062022-11-12 04:44:31 +0000456 inline const std::string getLocation() { return mDevice.getLocation(); }
Arpit Singh403e53c2023-04-18 11:46:56 +0000457 inline bool isExternal() const { return mDevice.isExternal(); }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800458 inline std::optional<uint8_t> getAssociatedDisplayPort() const {
459 return mDevice.getAssociatedDisplayPort();
460 }
Antonio Kantek0ac5e092024-04-22 17:10:27 +0000461 inline std::optional<std::string> getAssociatedDisplayUniqueIdByPort() const {
462 return mDevice.getAssociatedDisplayUniqueIdByPort();
463 }
464 inline std::optional<std::string> getAssociatedDisplayUniqueIdByDescriptor() const {
465 return mDevice.getAssociatedDisplayUniqueIdByDescriptor();
Christine Franks2a2293c2022-01-18 11:51:16 -0800466 }
Ambrus Weisz7bc23bf2022-10-04 13:13:07 +0000467 inline std::optional<std::string> getDeviceTypeAssociation() const {
468 return mDevice.getDeviceTypeAssociation();
469 }
Harry Cutts92559ef2024-01-05 12:45:36 +0000470 virtual std::optional<DisplayViewport> getAssociatedViewport() const {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800471 return mDevice.getAssociatedViewport();
472 }
Siarhei Vishniakou2935db72022-09-22 13:35:22 -0700473 [[nodiscard]] inline std::list<NotifyArgs> cancelTouch(nsecs_t when, nsecs_t readTime) {
474 return mDevice.cancelTouch(when, readTime);
475 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800476 inline void bumpGeneration() { mDevice.bumpGeneration(); }
Arpit Singh403e53c2023-04-18 11:46:56 +0000477 inline const PropertyMap& getConfiguration() const { return mDevice.getConfiguration(); }
Vaibhav Devmurarie58ffb92024-05-22 17:38:25 +0000478 inline KeyboardType getKeyboardType() const { return mDevice.getKeyboardType(); }
479 inline void setKeyboardType(KeyboardType keyboardType) {
480 return mDevice.setKeyboardType(keyboardType);
481 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800482
483private:
484 InputDevice& mDevice;
485 InputReaderContext* mContext;
486 EventHubInterface* mEventHub;
487 int32_t mId;
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800488 int32_t mDeviceId;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800489};
490
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700491} // namespace android