Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 1 | /* |
| 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 | |
chaviw | 98318de | 2021-05-19 16:45:23 -0500 | [diff] [blame] | 20 | #include <ftl/Flags.h> |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 21 | #include <input/DisplayViewport.h> |
| 22 | #include <input/InputDevice.h> |
Siarhei Vishniakou | 32f36ae | 2020-09-02 20:17:10 -0700 | [diff] [blame] | 23 | #include <input/PropertyMap.h> |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 24 | #include <stdint.h> |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 25 | |
| 26 | #include <optional> |
| 27 | #include <unordered_map> |
| 28 | #include <vector> |
| 29 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 30 | #include "EventHub.h" |
| 31 | #include "InputReaderBase.h" |
| 32 | #include "InputReaderContext.h" |
| 33 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 34 | namespace android { |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame] | 35 | // TODO b/180733860 support multiple battery in API and remove this. |
| 36 | constexpr int32_t DEFAULT_BATTERY_ID = 1; |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 37 | |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame] | 38 | class PeripheralController; |
| 39 | class PeripheralControllerInterface; |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 40 | class InputDeviceContext; |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 41 | class InputMapper; |
| 42 | |
| 43 | /* Represents the state of a single input device. */ |
| 44 | class InputDevice { |
| 45 | public: |
| 46 | InputDevice(InputReaderContext* context, int32_t id, int32_t generation, |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 47 | const InputDeviceIdentifier& identifier); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 48 | ~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 Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 56 | inline Flags<InputDeviceClass> getClasses() const { return mClasses; } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 57 | inline uint32_t getSources() const { return mSources; } |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 58 | inline bool hasEventHubDevices() const { return !mDevices.empty(); } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 59 | |
| 60 | inline bool isExternal() { return mIsExternal; } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 61 | inline std::optional<uint8_t> getAssociatedDisplayPort() const { |
| 62 | return mAssociatedDisplayPort; |
| 63 | } |
| 64 | inline std::optional<DisplayViewport> getAssociatedViewport() const { |
| 65 | return mAssociatedViewport; |
| 66 | } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 67 | inline bool hasMic() const { return mHasMic; } |
| 68 | |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 69 | inline bool isIgnored() { return !getMapperCount(); } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 70 | |
| 71 | bool isEnabled(); |
| 72 | void setEnabled(bool enabled, nsecs_t when); |
| 73 | |
Chris Ye | e731003 | 2020-09-22 15:36:28 -0700 | [diff] [blame] | 74 | void dump(std::string& dump, const std::string& eventHubDevStr); |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 75 | void addEventHubDevice(int32_t eventHubId, bool populateMappers = true); |
| 76 | void removeEventHubDevice(int32_t eventHubId); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 77 | 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 Vishniakou | 1983a71 | 2021-06-04 19:27:09 +0000 | [diff] [blame] | 83 | InputDeviceInfo getDeviceInfo(); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 84 | 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 Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 89 | void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 90 | void cancelVibrate(int32_t token); |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 91 | bool isVibrating(); |
| 92 | std::vector<int32_t> getVibratorIds(); |
Siarhei Vishniakou | 58ba3d1 | 2021-02-11 01:31:07 +0000 | [diff] [blame] | 93 | void cancelTouch(nsecs_t when, nsecs_t readTime); |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 94 | bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, |
| 95 | std::chrono::microseconds maxBatchReportLatency); |
| 96 | void disableSensor(InputDeviceSensorType sensorType); |
| 97 | void flushSensor(InputDeviceSensorType sensorType); |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 98 | |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 99 | std::optional<int32_t> getBatteryCapacity(); |
| 100 | std::optional<int32_t> getBatteryStatus(); |
| 101 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 102 | 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 Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 107 | int32_t getMetaState(); |
| 108 | void updateMetaState(int32_t keyCode); |
| 109 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 110 | 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 Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 117 | std::optional<int32_t> getAssociatedDisplayId(); |
| 118 | |
arthurhung | c903df1 | 2020-08-11 15:08:42 +0800 | [diff] [blame] | 119 | void updateLedState(bool reset); |
| 120 | |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 121 | size_t getMapperCount(); |
| 122 | |
Nathaniel R. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 123 | // construct and add a mapper to the input device |
| 124 | template <class T, typename... Args> |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 125 | 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. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 135 | return *mapper; |
| 136 | } |
| 137 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 138 | // 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 Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 152 | private: |
| 153 | InputReaderContext* mContext; |
| 154 | int32_t mId; |
| 155 | int32_t mGeneration; |
| 156 | int32_t mControllerNumber; |
| 157 | InputDeviceIdentifier mIdentifier; |
| 158 | std::string mAlias; |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 159 | Flags<InputDeviceClass> mClasses; |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 160 | |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 161 | // 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 Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 164 | // Map from EventHub ID to pair of device context and vector of mapper. |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 165 | std::unordered_map<int32_t, DevicePair> mDevices; |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 166 | // Misc devices controller for lights, battery, etc. |
Chris Ye | 1dd2e5c | 2021-04-04 23:12:41 -0700 | [diff] [blame] | 167 | std::unique_ptr<PeripheralControllerInterface> mController; |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 168 | |
| 169 | uint32_t mSources; |
| 170 | bool mIsExternal; |
| 171 | std::optional<uint8_t> mAssociatedDisplayPort; |
Christine Franks | 1ba71cc | 2021-04-07 14:37:42 -0700 | [diff] [blame] | 172 | std::optional<std::string> mAssociatedDisplayUniqueId; |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 173 | 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. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 181 | |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 182 | // helpers to interate over the devices collection |
| 183 | // run a function against every mapper on every subdevice |
Nathaniel R. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 184 | inline void for_each_mapper(std::function<void(InputMapper&)> f) { |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 185 | 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. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 213 | } |
| 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. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 220 | 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. Lewis | f4916ef | 2020-01-14 11:57:18 -0800 | [diff] [blame] | 228 | } |
| 229 | } |
| 230 | return std::nullopt; |
| 231 | } |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 232 | }; |
| 233 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 234 | /* 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 | */ |
| 239 | class InputDeviceContext { |
| 240 | public: |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 241 | InputDeviceContext(InputDevice& device, int32_t eventHubId); |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 242 | ~InputDeviceContext(); |
| 243 | |
| 244 | inline InputReaderContext* getContext() { return mContext; } |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 245 | inline int32_t getId() { return mDeviceId; } |
| 246 | inline int32_t getEventHubId() { return mId; } |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 247 | |
Chris Ye | 1b0c734 | 2020-07-28 21:57:03 -0700 | [diff] [blame] | 248 | inline Flags<InputDeviceClass> getDeviceClasses() const { |
| 249 | return mEventHub->getDeviceClasses(mId); |
| 250 | } |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 251 | 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 Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 266 | inline bool hasInputProperty(int32_t property) const { |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 267 | return mEventHub->hasInputProperty(mId, property); |
| 268 | } |
Chris Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 269 | |
| 270 | inline bool hasMscEvent(int mscEvent) const { return mEventHub->hasMscEvent(mId, mscEvent); } |
| 271 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 272 | 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 Ye | f59a2f4 | 2020-10-16 12:55:26 -0700 | [diff] [blame] | 280 | inline base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode) { |
| 281 | return mEventHub->mapSensor(mId, absCode); |
| 282 | } |
| 283 | |
Chris Ye | 3fdbfef | 2021-01-06 18:45:18 -0800 | [diff] [blame] | 284 | 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. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 308 | 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 Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 331 | inline const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap() const { |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 332 | return mEventHub->getKeyCharacterMap(mId); |
| 333 | } |
Chris Ye | 3a1e446 | 2020-08-12 10:13:15 -0700 | [diff] [blame] | 334 | inline bool setKeyboardLayoutOverlay(std::shared_ptr<KeyCharacterMap> map) { |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 335 | return mEventHub->setKeyboardLayoutOverlay(mId, map); |
| 336 | } |
Nathaniel R. Lewis | cacd69a | 2019-08-12 22:07:00 +0000 | [diff] [blame] | 337 | inline void vibrate(const VibrationElement& element) { |
| 338 | return mEventHub->vibrate(mId, element); |
| 339 | } |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 340 | inline void cancelVibrate() { return mEventHub->cancelVibrate(mId); } |
| 341 | |
Chris Ye | 8714371 | 2020-11-10 05:05:58 +0000 | [diff] [blame] | 342 | inline std::vector<int32_t> getVibratorIds() { return mEventHub->getVibratorIds(mId); } |
| 343 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 344 | inline const std::vector<int32_t> getRawBatteryIds() { |
| 345 | return mEventHub->getRawBatteryIds(mId); |
Kim Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 346 | } |
| 347 | |
Chris Ye | e2b1e5c | 2021-03-10 22:45:12 -0800 | [diff] [blame] | 348 | 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 Low | 03ea035 | 2020-11-06 12:45:07 -0800 | [diff] [blame] | 359 | |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 360 | 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 Vishniakou | 58ba3d1 | 2021-02-11 01:31:07 +0000 | [diff] [blame] | 386 | inline void cancelTouch(nsecs_t when, nsecs_t readTime) { mDevice.cancelTouch(when, readTime); } |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 387 | inline void bumpGeneration() { mDevice.bumpGeneration(); } |
| 388 | inline const PropertyMap& getConfiguration() { return mDevice.getConfiguration(); } |
| 389 | |
| 390 | private: |
| 391 | InputDevice& mDevice; |
| 392 | InputReaderContext* mContext; |
| 393 | EventHubInterface* mEventHub; |
| 394 | int32_t mId; |
Nathaniel R. Lewis | a7b82e1 | 2020-02-12 15:40:45 -0800 | [diff] [blame] | 395 | int32_t mDeviceId; |
Nathaniel R. Lewis | 26ec222 | 2020-01-10 16:30:54 -0800 | [diff] [blame] | 396 | }; |
| 397 | |
Prabir Pradhan | baa5c82 | 2019-08-30 15:27:05 -0700 | [diff] [blame] | 398 | } // namespace android |
| 399 | |
| 400 | #endif //_UI_INPUTREADER_INPUT_DEVICE_H |