blob: f32472d37b61199393b6cd7d45ccb7f38b95b6bb [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
17#ifndef _UI_INPUTREADER_INPUT_DEVICE_H
18#define _UI_INPUTREADER_INPUT_DEVICE_H
19
chaviw98318de2021-05-19 16:45:23 -050020#include <ftl/Flags.h>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080021#include <input/DisplayViewport.h>
22#include <input/InputDevice.h>
Siarhei Vishniakou32f36ae2020-09-02 20:17:10 -070023#include <input/PropertyMap.h>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080024#include <stdint.h>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080025
26#include <optional>
27#include <unordered_map>
28#include <vector>
29
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070030#include "EventHub.h"
31#include "InputReaderBase.h"
32#include "InputReaderContext.h"
33
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070034namespace android {
Chris Ye1dd2e5c2021-04-04 23:12:41 -070035// TODO b/180733860 support multiple battery in API and remove this.
36constexpr int32_t DEFAULT_BATTERY_ID = 1;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070037
Chris Ye1dd2e5c2021-04-04 23:12:41 -070038class PeripheralController;
39class PeripheralControllerInterface;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -080040class InputDeviceContext;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070041class InputMapper;
42
43/* Represents the state of a single input device. */
44class InputDevice {
45public:
46 InputDevice(InputReaderContext* context, int32_t id, int32_t generation,
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080047 const InputDeviceIdentifier& identifier);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070048 ~InputDevice();
49
50 inline InputReaderContext* getContext() { return mContext; }
51 inline int32_t getId() const { return mId; }
52 inline int32_t getControllerNumber() const { return mControllerNumber; }
53 inline int32_t getGeneration() const { return mGeneration; }
54 inline const std::string getName() const { return mIdentifier.name; }
55 inline const std::string getDescriptor() { return mIdentifier.descriptor; }
Chris Ye1b0c7342020-07-28 21:57:03 -070056 inline Flags<InputDeviceClass> getClasses() const { return mClasses; }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070057 inline uint32_t getSources() const { return mSources; }
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080058 inline bool hasEventHubDevices() const { return !mDevices.empty(); }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070059
60 inline bool isExternal() { return mIsExternal; }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070061 inline std::optional<uint8_t> getAssociatedDisplayPort() const {
62 return mAssociatedDisplayPort;
63 }
64 inline std::optional<DisplayViewport> getAssociatedViewport() const {
65 return mAssociatedViewport;
66 }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070067 inline bool hasMic() const { return mHasMic; }
68
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080069 inline bool isIgnored() { return !getMapperCount(); }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070070
71 bool isEnabled();
72 void setEnabled(bool enabled, nsecs_t when);
73
Chris Yee7310032020-09-22 15:36:28 -070074 void dump(std::string& dump, const std::string& eventHubDevStr);
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -080075 void addEventHubDevice(int32_t eventHubId, bool populateMappers = true);
76 void removeEventHubDevice(int32_t eventHubId);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070077 void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
78 void reset(nsecs_t when);
79 void process(const RawEvent* rawEvents, size_t count);
80 void timeoutExpired(nsecs_t when);
81 void updateExternalStylusState(const StylusState& state);
82
Siarhei Vishniakou1983a712021-06-04 19:27:09 +000083 InputDeviceInfo getDeviceInfo();
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070084 int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode);
85 int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode);
86 int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode);
87 bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, const int32_t* keyCodes,
88 uint8_t* outFlags);
Chris Ye87143712020-11-10 05:05:58 +000089 void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070090 void cancelVibrate(int32_t token);
Chris Ye87143712020-11-10 05:05:58 +000091 bool isVibrating();
92 std::vector<int32_t> getVibratorIds();
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +000093 void cancelTouch(nsecs_t when, nsecs_t readTime);
Chris Yef59a2f42020-10-16 12:55:26 -070094 bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod,
95 std::chrono::microseconds maxBatchReportLatency);
96 void disableSensor(InputDeviceSensorType sensorType);
97 void flushSensor(InputDeviceSensorType sensorType);
Prabir Pradhanbaa5c822019-08-30 15:27:05 -070098
Kim Low03ea0352020-11-06 12:45:07 -080099 std::optional<int32_t> getBatteryCapacity();
100 std::optional<int32_t> getBatteryStatus();
101
Chris Ye3fdbfef2021-01-06 18:45:18 -0800102 bool setLightColor(int32_t lightId, int32_t color);
103 bool setLightPlayerId(int32_t lightId, int32_t playerId);
104 std::optional<int32_t> getLightColor(int32_t lightId);
105 std::optional<int32_t> getLightPlayerId(int32_t lightId);
106
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700107 int32_t getMetaState();
108 void updateMetaState(int32_t keyCode);
109
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700110 void bumpGeneration();
111
112 void notifyReset(nsecs_t when);
113
114 inline const PropertyMap& getConfiguration() { return mConfiguration; }
115 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
116
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700117 std::optional<int32_t> getAssociatedDisplayId();
118
arthurhungc903df12020-08-11 15:08:42 +0800119 void updateLedState(bool reset);
120
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800121 size_t getMapperCount();
122
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800123 // construct and add a mapper to the input device
124 template <class T, typename... Args>
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800125 T& addMapper(int32_t eventHubId, Args... args) {
126 // ensure a device entry exists for this eventHubId
127 addEventHubDevice(eventHubId, false);
128
129 // create mapper
130 auto& devicePair = mDevices[eventHubId];
131 auto& deviceContext = devicePair.first;
132 auto& mappers = devicePair.second;
133 T* mapper = new T(*deviceContext, args...);
134 mappers.emplace_back(mapper);
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800135 return *mapper;
136 }
137
Chris Yee2b1e5c2021-03-10 22:45:12 -0800138 // construct and add a controller to the input device
139 template <class T>
140 T& addController(int32_t eventHubId) {
141 // ensure a device entry exists for this eventHubId
142 addEventHubDevice(eventHubId, false);
143
144 // create controller
145 auto& devicePair = mDevices[eventHubId];
146 auto& deviceContext = devicePair.first;
147
148 mController = std::make_unique<T>(*deviceContext);
149 return *(reinterpret_cast<T*>(mController.get()));
150 }
151
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700152private:
153 InputReaderContext* mContext;
154 int32_t mId;
155 int32_t mGeneration;
156 int32_t mControllerNumber;
157 InputDeviceIdentifier mIdentifier;
158 std::string mAlias;
Chris Ye1b0c7342020-07-28 21:57:03 -0700159 Flags<InputDeviceClass> mClasses;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700160
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800161 // map from eventHubId to device context and mappers
162 using MapperVector = std::vector<std::unique_ptr<InputMapper>>;
163 using DevicePair = std::pair<std::unique_ptr<InputDeviceContext>, MapperVector>;
Chris Yee2b1e5c2021-03-10 22:45:12 -0800164 // Map from EventHub ID to pair of device context and vector of mapper.
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800165 std::unordered_map<int32_t, DevicePair> mDevices;
Chris Yee2b1e5c2021-03-10 22:45:12 -0800166 // Misc devices controller for lights, battery, etc.
Chris Ye1dd2e5c2021-04-04 23:12:41 -0700167 std::unique_ptr<PeripheralControllerInterface> mController;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700168
169 uint32_t mSources;
170 bool mIsExternal;
171 std::optional<uint8_t> mAssociatedDisplayPort;
Christine Franks1ba71cc2021-04-07 14:37:42 -0700172 std::optional<std::string> mAssociatedDisplayUniqueId;
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700173 std::optional<DisplayViewport> mAssociatedViewport;
174 bool mHasMic;
175 bool mDropUntilNextSync;
176
177 typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);
178 int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);
179
180 PropertyMap mConfiguration;
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800181
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800182 // helpers to interate over the devices collection
183 // run a function against every mapper on every subdevice
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800184 inline void for_each_mapper(std::function<void(InputMapper&)> f) {
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800185 for (auto& deviceEntry : mDevices) {
186 auto& devicePair = deviceEntry.second;
187 auto& mappers = devicePair.second;
188 for (auto& mapperPtr : mappers) {
189 f(*mapperPtr);
190 }
191 }
192 }
193
194 // run a function against every mapper on a specific subdevice
195 inline void for_each_mapper_in_subdevice(int32_t eventHubDevice,
196 std::function<void(InputMapper&)> f) {
197 auto deviceIt = mDevices.find(eventHubDevice);
198 if (deviceIt != mDevices.end()) {
199 auto& devicePair = deviceIt->second;
200 auto& mappers = devicePair.second;
201 for (auto& mapperPtr : mappers) {
202 f(*mapperPtr);
203 }
204 }
205 }
206
207 // run a function against every subdevice
208 inline void for_each_subdevice(std::function<void(InputDeviceContext&)> f) {
209 for (auto& deviceEntry : mDevices) {
210 auto& devicePair = deviceEntry.second;
211 auto& contextPtr = devicePair.first;
212 f(*contextPtr);
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800213 }
214 }
215
216 // return the first value returned by a function over every mapper.
217 // if all mappers return nullopt, return nullopt.
218 template <typename T>
219 inline std::optional<T> first_in_mappers(std::function<std::optional<T>(InputMapper&)> f) {
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800220 for (auto& deviceEntry : mDevices) {
221 auto& devicePair = deviceEntry.second;
222 auto& mappers = devicePair.second;
223 for (auto& mapperPtr : mappers) {
224 std::optional<T> ret = f(*mapperPtr);
225 if (ret) {
226 return ret;
227 }
Nathaniel R. Lewisf4916ef2020-01-14 11:57:18 -0800228 }
229 }
230 return std::nullopt;
231 }
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700232};
233
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800234/* Provides access to EventHub methods, but limits access to the current InputDevice.
235 * Essentially an implementation of EventHubInterface, but for a specific device id.
236 * Helps hide implementation details of InputDevice and EventHub. Used by mappers to
237 * check the status of the associated hardware device
238 */
239class InputDeviceContext {
240public:
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800241 InputDeviceContext(InputDevice& device, int32_t eventHubId);
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800242 ~InputDeviceContext();
243
244 inline InputReaderContext* getContext() { return mContext; }
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800245 inline int32_t getId() { return mDeviceId; }
246 inline int32_t getEventHubId() { return mId; }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800247
Chris Ye1b0c7342020-07-28 21:57:03 -0700248 inline Flags<InputDeviceClass> getDeviceClasses() const {
249 return mEventHub->getDeviceClasses(mId);
250 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800251 inline InputDeviceIdentifier getDeviceIdentifier() const {
252 return mEventHub->getDeviceIdentifier(mId);
253 }
254 inline int32_t getDeviceControllerNumber() const {
255 return mEventHub->getDeviceControllerNumber(mId);
256 }
257 inline void getConfiguration(PropertyMap* outConfiguration) const {
258 return mEventHub->getConfiguration(mId, outConfiguration);
259 }
260 inline status_t getAbsoluteAxisInfo(int32_t code, RawAbsoluteAxisInfo* axisInfo) const {
261 return mEventHub->getAbsoluteAxisInfo(mId, code, axisInfo);
262 }
263 inline bool hasRelativeAxis(int32_t code) const {
264 return mEventHub->hasRelativeAxis(mId, code);
265 }
Chris Yef59a2f42020-10-16 12:55:26 -0700266 inline bool hasInputProperty(int32_t property) const {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800267 return mEventHub->hasInputProperty(mId, property);
268 }
Chris Yef59a2f42020-10-16 12:55:26 -0700269
270 inline bool hasMscEvent(int mscEvent) const { return mEventHub->hasMscEvent(mId, mscEvent); }
271
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800272 inline status_t mapKey(int32_t scanCode, int32_t usageCode, int32_t metaState,
273 int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
274 return mEventHub->mapKey(mId, scanCode, usageCode, metaState, outKeycode, outMetaState,
275 outFlags);
276 }
277 inline status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const {
278 return mEventHub->mapAxis(mId, scanCode, outAxisInfo);
279 }
Chris Yef59a2f42020-10-16 12:55:26 -0700280 inline base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode) {
281 return mEventHub->mapSensor(mId, absCode);
282 }
283
Chris Ye3fdbfef2021-01-06 18:45:18 -0800284 inline const std::vector<int32_t> getRawLightIds() { return mEventHub->getRawLightIds(mId); }
285
286 inline std::optional<RawLightInfo> getRawLightInfo(int32_t lightId) {
287 return mEventHub->getRawLightInfo(mId, lightId);
288 }
289
290 inline std::optional<int32_t> getLightBrightness(int32_t lightId) {
291 return mEventHub->getLightBrightness(mId, lightId);
292 }
293
294 inline void setLightBrightness(int32_t lightId, int32_t brightness) {
295 return mEventHub->setLightBrightness(mId, lightId, brightness);
296 }
297
298 inline std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
299 int32_t lightId) {
300 return mEventHub->getLightIntensities(mId, lightId);
301 }
302
303 inline void setLightIntensities(int32_t lightId,
304 std::unordered_map<LightColor, int32_t> intensities) {
305 return mEventHub->setLightIntensities(mId, lightId, intensities);
306 }
307
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800308 inline std::vector<TouchVideoFrame> getVideoFrames() { return mEventHub->getVideoFrames(mId); }
309 inline int32_t getScanCodeState(int32_t scanCode) const {
310 return mEventHub->getScanCodeState(mId, scanCode);
311 }
312 inline int32_t getKeyCodeState(int32_t keyCode) const {
313 return mEventHub->getKeyCodeState(mId, keyCode);
314 }
315 inline int32_t getSwitchState(int32_t sw) const { return mEventHub->getSwitchState(mId, sw); }
316 inline status_t getAbsoluteAxisValue(int32_t code, int32_t* outValue) const {
317 return mEventHub->getAbsoluteAxisValue(mId, code, outValue);
318 }
319 inline bool markSupportedKeyCodes(size_t numCodes, const int32_t* keyCodes,
320 uint8_t* outFlags) const {
321 return mEventHub->markSupportedKeyCodes(mId, numCodes, keyCodes, outFlags);
322 }
323 inline bool hasScanCode(int32_t scanCode) const {
324 return mEventHub->hasScanCode(mId, scanCode);
325 }
326 inline bool hasLed(int32_t led) const { return mEventHub->hasLed(mId, led); }
327 inline void setLedState(int32_t led, bool on) { return mEventHub->setLedState(mId, led, on); }
328 inline void getVirtualKeyDefinitions(std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
329 return mEventHub->getVirtualKeyDefinitions(mId, outVirtualKeys);
330 }
Chris Ye3a1e4462020-08-12 10:13:15 -0700331 inline const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap() const {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800332 return mEventHub->getKeyCharacterMap(mId);
333 }
Chris Ye3a1e4462020-08-12 10:13:15 -0700334 inline bool setKeyboardLayoutOverlay(std::shared_ptr<KeyCharacterMap> map) {
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800335 return mEventHub->setKeyboardLayoutOverlay(mId, map);
336 }
Nathaniel R. Lewiscacd69a2019-08-12 22:07:00 +0000337 inline void vibrate(const VibrationElement& element) {
338 return mEventHub->vibrate(mId, element);
339 }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800340 inline void cancelVibrate() { return mEventHub->cancelVibrate(mId); }
341
Chris Ye87143712020-11-10 05:05:58 +0000342 inline std::vector<int32_t> getVibratorIds() { return mEventHub->getVibratorIds(mId); }
343
Chris Yee2b1e5c2021-03-10 22:45:12 -0800344 inline const std::vector<int32_t> getRawBatteryIds() {
345 return mEventHub->getRawBatteryIds(mId);
Kim Low03ea0352020-11-06 12:45:07 -0800346 }
347
Chris Yee2b1e5c2021-03-10 22:45:12 -0800348 inline std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t batteryId) {
349 return mEventHub->getRawBatteryInfo(mId, batteryId);
350 }
351
352 inline std::optional<int32_t> getBatteryCapacity(int32_t batteryId) {
353 return mEventHub->getBatteryCapacity(mId, batteryId);
354 }
355
356 inline std::optional<int32_t> getBatteryStatus(int32_t batteryId) {
357 return mEventHub->getBatteryStatus(mId, batteryId);
358 }
Kim Low03ea0352020-11-06 12:45:07 -0800359
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800360 inline bool hasAbsoluteAxis(int32_t code) const {
361 RawAbsoluteAxisInfo info;
362 mEventHub->getAbsoluteAxisInfo(mId, code, &info);
363 return info.valid;
364 }
365 inline bool isKeyPressed(int32_t code) const {
366 return mEventHub->getScanCodeState(mId, code) == AKEY_STATE_DOWN;
367 }
368 inline int32_t getAbsoluteAxisValue(int32_t code) const {
369 int32_t value;
370 mEventHub->getAbsoluteAxisValue(mId, code, &value);
371 return value;
372 }
373 inline bool isDeviceEnabled() { return mEventHub->isDeviceEnabled(mId); }
374 inline status_t enableDevice() { return mEventHub->enableDevice(mId); }
375 inline status_t disableDevice() { return mEventHub->disableDevice(mId); }
376
377 inline const std::string getName() { return mDevice.getName(); }
378 inline const std::string getDescriptor() { return mDevice.getDescriptor(); }
379 inline bool isExternal() { return mDevice.isExternal(); }
380 inline std::optional<uint8_t> getAssociatedDisplayPort() const {
381 return mDevice.getAssociatedDisplayPort();
382 }
383 inline std::optional<DisplayViewport> getAssociatedViewport() const {
384 return mDevice.getAssociatedViewport();
385 }
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +0000386 inline void cancelTouch(nsecs_t when, nsecs_t readTime) { mDevice.cancelTouch(when, readTime); }
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800387 inline void bumpGeneration() { mDevice.bumpGeneration(); }
388 inline const PropertyMap& getConfiguration() { return mDevice.getConfiguration(); }
389
390private:
391 InputDevice& mDevice;
392 InputReaderContext* mContext;
393 EventHubInterface* mEventHub;
394 int32_t mId;
Nathaniel R. Lewisa7b82e12020-02-12 15:40:45 -0800395 int32_t mDeviceId;
Nathaniel R. Lewis26ec2222020-01-10 16:30:54 -0800396};
397
Prabir Pradhanbaa5c822019-08-30 15:27:05 -0700398} // namespace android
399
400#endif //_UI_INPUTREADER_INPUT_DEVICE_H