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 20 #include <ftl/flags.h> 21 #include <input/DisplayViewport.h> 22 #include <input/InputDevice.h> 23 #include <input/PropertyMap.h> 24 25 #include <cstdint> 26 #include <optional> 27 #include <unordered_map> 28 #include <vector> 29 30 #include "EventHub.h" 31 #include "InputReaderBase.h" 32 #include "InputReaderContext.h" 33 34 namespace android { 35 // TODO b/180733860 support multiple battery in API and remove this. 36 constexpr int32_t DEFAULT_BATTERY_ID = 1; 37 38 class PeripheralController; 39 class PeripheralControllerInterface; 40 class InputDeviceContext; 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, 47 const InputDeviceIdentifier& identifier); 48 ~InputDevice(); 49 getContext()50 inline InputReaderContext* getContext() { return mContext; } getId()51 inline int32_t getId() const { return mId; } getControllerNumber()52 inline int32_t getControllerNumber() const { return mControllerNumber; } getGeneration()53 inline int32_t getGeneration() const { return mGeneration; } getName()54 inline const std::string getName() const { return mIdentifier.name; } getDescriptor()55 inline const std::string getDescriptor() { return mIdentifier.descriptor; } getClasses()56 inline ftl::Flags<InputDeviceClass> getClasses() const { return mClasses; } getSources()57 inline uint32_t getSources() const { return mSources; } hasEventHubDevices()58 inline bool hasEventHubDevices() const { return !mDevices.empty(); } 59 isExternal()60 inline bool isExternal() { return mIsExternal; } getAssociatedDisplayPort()61 inline std::optional<uint8_t> getAssociatedDisplayPort() const { 62 return mAssociatedDisplayPort; 63 } getAssociatedDisplayUniqueId()64 inline std::optional<std::string> getAssociatedDisplayUniqueId() const { 65 return mAssociatedDisplayUniqueId; 66 } getAssociatedViewport()67 inline std::optional<DisplayViewport> getAssociatedViewport() const { 68 return mAssociatedViewport; 69 } hasMic()70 inline bool hasMic() const { return mHasMic; } 71 isIgnored()72 inline bool isIgnored() { return !getMapperCount(); } 73 74 bool isEnabled(); 75 void setEnabled(bool enabled, nsecs_t when); 76 77 void dump(std::string& dump, const std::string& eventHubDevStr); 78 void addEventHubDevice(int32_t eventHubId, bool populateMappers = true); 79 void removeEventHubDevice(int32_t eventHubId); 80 void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes); 81 void reset(nsecs_t when); 82 void process(const RawEvent* rawEvents, size_t count); 83 void timeoutExpired(nsecs_t when); 84 void updateExternalStylusState(const StylusState& state); 85 86 InputDeviceInfo getDeviceInfo(); 87 int32_t getKeyCodeState(uint32_t sourceMask, int32_t keyCode); 88 int32_t getScanCodeState(uint32_t sourceMask, int32_t scanCode); 89 int32_t getSwitchState(uint32_t sourceMask, int32_t switchCode); 90 int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const; 91 bool markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes, const int32_t* keyCodes, 92 uint8_t* outFlags); 93 void vibrate(const VibrationSequence& sequence, ssize_t repeat, int32_t token); 94 void cancelVibrate(int32_t token); 95 bool isVibrating(); 96 std::vector<int32_t> getVibratorIds(); 97 void cancelTouch(nsecs_t when, nsecs_t readTime); 98 bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod, 99 std::chrono::microseconds maxBatchReportLatency); 100 void disableSensor(InputDeviceSensorType sensorType); 101 void flushSensor(InputDeviceSensorType sensorType); 102 103 std::optional<int32_t> getBatteryCapacity(); 104 std::optional<int32_t> getBatteryStatus(); 105 106 bool setLightColor(int32_t lightId, int32_t color); 107 bool setLightPlayerId(int32_t lightId, int32_t playerId); 108 std::optional<int32_t> getLightColor(int32_t lightId); 109 std::optional<int32_t> getLightPlayerId(int32_t lightId); 110 111 int32_t getMetaState(); 112 void updateMetaState(int32_t keyCode); 113 114 void bumpGeneration(); 115 116 void notifyReset(nsecs_t when); 117 getConfiguration()118 inline const PropertyMap& getConfiguration() { return mConfiguration; } getEventHub()119 inline EventHubInterface* getEventHub() { return mContext->getEventHub(); } 120 121 std::optional<int32_t> getAssociatedDisplayId(); 122 123 void updateLedState(bool reset); 124 125 size_t getMapperCount(); 126 127 // construct and add a mapper to the input device 128 template <class T, typename... Args> addMapper(int32_t eventHubId,Args...args)129 T& addMapper(int32_t eventHubId, Args... args) { 130 // ensure a device entry exists for this eventHubId 131 addEventHubDevice(eventHubId, false); 132 133 // create mapper 134 auto& devicePair = mDevices[eventHubId]; 135 auto& deviceContext = devicePair.first; 136 auto& mappers = devicePair.second; 137 T* mapper = new T(*deviceContext, args...); 138 mappers.emplace_back(mapper); 139 return *mapper; 140 } 141 142 // construct and add a controller to the input device 143 template <class T> addController(int32_t eventHubId)144 T& addController(int32_t eventHubId) { 145 // ensure a device entry exists for this eventHubId 146 addEventHubDevice(eventHubId, false); 147 148 // create controller 149 auto& devicePair = mDevices[eventHubId]; 150 auto& deviceContext = devicePair.first; 151 152 mController = std::make_unique<T>(*deviceContext); 153 return *(reinterpret_cast<T*>(mController.get())); 154 } 155 156 private: 157 InputReaderContext* mContext; 158 int32_t mId; 159 int32_t mGeneration; 160 int32_t mControllerNumber; 161 InputDeviceIdentifier mIdentifier; 162 std::string mAlias; 163 ftl::Flags<InputDeviceClass> mClasses; 164 165 // map from eventHubId to device context and mappers 166 using MapperVector = std::vector<std::unique_ptr<InputMapper>>; 167 using DevicePair = std::pair<std::unique_ptr<InputDeviceContext>, MapperVector>; 168 // Map from EventHub ID to pair of device context and vector of mapper. 169 std::unordered_map<int32_t, DevicePair> mDevices; 170 // Misc devices controller for lights, battery, etc. 171 std::unique_ptr<PeripheralControllerInterface> mController; 172 173 uint32_t mSources; 174 bool mIsExternal; 175 std::optional<uint8_t> mAssociatedDisplayPort; 176 std::optional<std::string> mAssociatedDisplayUniqueId; 177 std::optional<DisplayViewport> mAssociatedViewport; 178 bool mHasMic; 179 bool mDropUntilNextSync; 180 181 typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code); 182 int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc); 183 184 PropertyMap mConfiguration; 185 186 // helpers to interate over the devices collection 187 // run a function against every mapper on every subdevice for_each_mapper(std::function<void (InputMapper &)> f)188 inline void for_each_mapper(std::function<void(InputMapper&)> f) { 189 for (auto& deviceEntry : mDevices) { 190 auto& devicePair = deviceEntry.second; 191 auto& mappers = devicePair.second; 192 for (auto& mapperPtr : mappers) { 193 f(*mapperPtr); 194 } 195 } 196 } 197 198 // run a function against every mapper on a specific subdevice for_each_mapper_in_subdevice(int32_t eventHubDevice,std::function<void (InputMapper &)> f)199 inline void for_each_mapper_in_subdevice(int32_t eventHubDevice, 200 std::function<void(InputMapper&)> f) { 201 auto deviceIt = mDevices.find(eventHubDevice); 202 if (deviceIt != mDevices.end()) { 203 auto& devicePair = deviceIt->second; 204 auto& mappers = devicePair.second; 205 for (auto& mapperPtr : mappers) { 206 f(*mapperPtr); 207 } 208 } 209 } 210 211 // run a function against every subdevice for_each_subdevice(std::function<void (InputDeviceContext &)> f)212 inline void for_each_subdevice(std::function<void(InputDeviceContext&)> f) { 213 for (auto& deviceEntry : mDevices) { 214 auto& devicePair = deviceEntry.second; 215 auto& contextPtr = devicePair.first; 216 f(*contextPtr); 217 } 218 } 219 220 // return the first value returned by a function over every mapper. 221 // if all mappers return nullopt, return nullopt. 222 template <typename T> first_in_mappers(std::function<std::optional<T> (InputMapper &)> f)223 inline std::optional<T> first_in_mappers( 224 std::function<std::optional<T>(InputMapper&)> f) const { 225 for (auto& deviceEntry : mDevices) { 226 auto& devicePair = deviceEntry.second; 227 auto& mappers = devicePair.second; 228 for (auto& mapperPtr : mappers) { 229 std::optional<T> ret = f(*mapperPtr); 230 if (ret) { 231 return ret; 232 } 233 } 234 } 235 return std::nullopt; 236 } 237 }; 238 239 /* Provides access to EventHub methods, but limits access to the current InputDevice. 240 * Essentially an implementation of EventHubInterface, but for a specific device id. 241 * Helps hide implementation details of InputDevice and EventHub. Used by mappers to 242 * check the status of the associated hardware device 243 */ 244 class InputDeviceContext { 245 public: 246 InputDeviceContext(InputDevice& device, int32_t eventHubId); 247 ~InputDeviceContext(); 248 getContext()249 inline InputReaderContext* getContext() { return mContext; } getId()250 inline int32_t getId() { return mDeviceId; } getEventHubId()251 inline int32_t getEventHubId() { return mId; } 252 getDeviceClasses()253 inline ftl::Flags<InputDeviceClass> getDeviceClasses() const { 254 return mEventHub->getDeviceClasses(mId); 255 } getDeviceIdentifier()256 inline InputDeviceIdentifier getDeviceIdentifier() const { 257 return mEventHub->getDeviceIdentifier(mId); 258 } getDeviceControllerNumber()259 inline int32_t getDeviceControllerNumber() const { 260 return mEventHub->getDeviceControllerNumber(mId); 261 } getConfiguration(PropertyMap * outConfiguration)262 inline void getConfiguration(PropertyMap* outConfiguration) const { 263 return mEventHub->getConfiguration(mId, outConfiguration); 264 } getAbsoluteAxisInfo(int32_t code,RawAbsoluteAxisInfo * axisInfo)265 inline status_t getAbsoluteAxisInfo(int32_t code, RawAbsoluteAxisInfo* axisInfo) const { 266 return mEventHub->getAbsoluteAxisInfo(mId, code, axisInfo); 267 } hasRelativeAxis(int32_t code)268 inline bool hasRelativeAxis(int32_t code) const { 269 return mEventHub->hasRelativeAxis(mId, code); 270 } hasInputProperty(int32_t property)271 inline bool hasInputProperty(int32_t property) const { 272 return mEventHub->hasInputProperty(mId, property); 273 } 274 hasMscEvent(int mscEvent)275 inline bool hasMscEvent(int mscEvent) const { return mEventHub->hasMscEvent(mId, mscEvent); } 276 mapKey(int32_t scanCode,int32_t usageCode,int32_t metaState,int32_t * outKeycode,int32_t * outMetaState,uint32_t * outFlags)277 inline status_t mapKey(int32_t scanCode, int32_t usageCode, int32_t metaState, 278 int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const { 279 return mEventHub->mapKey(mId, scanCode, usageCode, metaState, outKeycode, outMetaState, 280 outFlags); 281 } mapAxis(int32_t scanCode,AxisInfo * outAxisInfo)282 inline status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const { 283 return mEventHub->mapAxis(mId, scanCode, outAxisInfo); 284 } mapSensor(int32_t absCode)285 inline base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode) { 286 return mEventHub->mapSensor(mId, absCode); 287 } 288 getRawLightIds()289 inline const std::vector<int32_t> getRawLightIds() { return mEventHub->getRawLightIds(mId); } 290 getRawLightInfo(int32_t lightId)291 inline std::optional<RawLightInfo> getRawLightInfo(int32_t lightId) { 292 return mEventHub->getRawLightInfo(mId, lightId); 293 } 294 getLightBrightness(int32_t lightId)295 inline std::optional<int32_t> getLightBrightness(int32_t lightId) { 296 return mEventHub->getLightBrightness(mId, lightId); 297 } 298 setLightBrightness(int32_t lightId,int32_t brightness)299 inline void setLightBrightness(int32_t lightId, int32_t brightness) { 300 return mEventHub->setLightBrightness(mId, lightId, brightness); 301 } 302 getLightIntensities(int32_t lightId)303 inline std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities( 304 int32_t lightId) { 305 return mEventHub->getLightIntensities(mId, lightId); 306 } 307 setLightIntensities(int32_t lightId,std::unordered_map<LightColor,int32_t> intensities)308 inline void setLightIntensities(int32_t lightId, 309 std::unordered_map<LightColor, int32_t> intensities) { 310 return mEventHub->setLightIntensities(mId, lightId, intensities); 311 } 312 getVideoFrames()313 inline std::vector<TouchVideoFrame> getVideoFrames() { return mEventHub->getVideoFrames(mId); } getScanCodeState(int32_t scanCode)314 inline int32_t getScanCodeState(int32_t scanCode) const { 315 return mEventHub->getScanCodeState(mId, scanCode); 316 } getKeyCodeState(int32_t keyCode)317 inline int32_t getKeyCodeState(int32_t keyCode) const { 318 return mEventHub->getKeyCodeState(mId, keyCode); 319 } getKeyCodeForKeyLocation(int32_t locationKeyCode)320 inline int32_t getKeyCodeForKeyLocation(int32_t locationKeyCode) const { 321 return mEventHub->getKeyCodeForKeyLocation(mId, locationKeyCode); 322 } getSwitchState(int32_t sw)323 inline int32_t getSwitchState(int32_t sw) const { return mEventHub->getSwitchState(mId, sw); } getAbsoluteAxisValue(int32_t code,int32_t * outValue)324 inline status_t getAbsoluteAxisValue(int32_t code, int32_t* outValue) const { 325 return mEventHub->getAbsoluteAxisValue(mId, code, outValue); 326 } markSupportedKeyCodes(size_t numCodes,const int32_t * keyCodes,uint8_t * outFlags)327 inline bool markSupportedKeyCodes(size_t numCodes, const int32_t* keyCodes, 328 uint8_t* outFlags) const { 329 return mEventHub->markSupportedKeyCodes(mId, numCodes, keyCodes, outFlags); 330 } hasScanCode(int32_t scanCode)331 inline bool hasScanCode(int32_t scanCode) const { 332 return mEventHub->hasScanCode(mId, scanCode); 333 } hasKeyCode(int32_t keyCode)334 inline bool hasKeyCode(int32_t keyCode) const { return mEventHub->hasKeyCode(mId, keyCode); } hasLed(int32_t led)335 inline bool hasLed(int32_t led) const { return mEventHub->hasLed(mId, led); } setLedState(int32_t led,bool on)336 inline void setLedState(int32_t led, bool on) { return mEventHub->setLedState(mId, led, on); } getVirtualKeyDefinitions(std::vector<VirtualKeyDefinition> & outVirtualKeys)337 inline void getVirtualKeyDefinitions(std::vector<VirtualKeyDefinition>& outVirtualKeys) const { 338 return mEventHub->getVirtualKeyDefinitions(mId, outVirtualKeys); 339 } getKeyCharacterMap()340 inline const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap() const { 341 return mEventHub->getKeyCharacterMap(mId); 342 } setKeyboardLayoutOverlay(std::shared_ptr<KeyCharacterMap> map)343 inline bool setKeyboardLayoutOverlay(std::shared_ptr<KeyCharacterMap> map) { 344 return mEventHub->setKeyboardLayoutOverlay(mId, map); 345 } vibrate(const VibrationElement & element)346 inline void vibrate(const VibrationElement& element) { 347 return mEventHub->vibrate(mId, element); 348 } cancelVibrate()349 inline void cancelVibrate() { return mEventHub->cancelVibrate(mId); } 350 getVibratorIds()351 inline std::vector<int32_t> getVibratorIds() { return mEventHub->getVibratorIds(mId); } 352 getRawBatteryIds()353 inline const std::vector<int32_t> getRawBatteryIds() { 354 return mEventHub->getRawBatteryIds(mId); 355 } 356 getRawBatteryInfo(int32_t batteryId)357 inline std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t batteryId) { 358 return mEventHub->getRawBatteryInfo(mId, batteryId); 359 } 360 getBatteryCapacity(int32_t batteryId)361 inline std::optional<int32_t> getBatteryCapacity(int32_t batteryId) { 362 return mEventHub->getBatteryCapacity(mId, batteryId); 363 } 364 getBatteryStatus(int32_t batteryId)365 inline std::optional<int32_t> getBatteryStatus(int32_t batteryId) { 366 return mEventHub->getBatteryStatus(mId, batteryId); 367 } 368 hasAbsoluteAxis(int32_t code)369 inline bool hasAbsoluteAxis(int32_t code) const { 370 RawAbsoluteAxisInfo info; 371 mEventHub->getAbsoluteAxisInfo(mId, code, &info); 372 return info.valid; 373 } isKeyPressed(int32_t code)374 inline bool isKeyPressed(int32_t code) const { 375 return mEventHub->getScanCodeState(mId, code) == AKEY_STATE_DOWN; 376 } getAbsoluteAxisValue(int32_t code)377 inline int32_t getAbsoluteAxisValue(int32_t code) const { 378 int32_t value; 379 mEventHub->getAbsoluteAxisValue(mId, code, &value); 380 return value; 381 } isDeviceEnabled()382 inline bool isDeviceEnabled() { return mEventHub->isDeviceEnabled(mId); } enableDevice()383 inline status_t enableDevice() { return mEventHub->enableDevice(mId); } disableDevice()384 inline status_t disableDevice() { return mEventHub->disableDevice(mId); } 385 getName()386 inline const std::string getName() { return mDevice.getName(); } getDescriptor()387 inline const std::string getDescriptor() { return mDevice.getDescriptor(); } isExternal()388 inline bool isExternal() { return mDevice.isExternal(); } getAssociatedDisplayPort()389 inline std::optional<uint8_t> getAssociatedDisplayPort() const { 390 return mDevice.getAssociatedDisplayPort(); 391 } getAssociatedDisplayUniqueId()392 inline std::optional<std::string> getAssociatedDisplayUniqueId() const { 393 return mDevice.getAssociatedDisplayUniqueId(); 394 } getAssociatedViewport()395 inline std::optional<DisplayViewport> getAssociatedViewport() const { 396 return mDevice.getAssociatedViewport(); 397 } cancelTouch(nsecs_t when,nsecs_t readTime)398 inline void cancelTouch(nsecs_t when, nsecs_t readTime) { mDevice.cancelTouch(when, readTime); } bumpGeneration()399 inline void bumpGeneration() { mDevice.bumpGeneration(); } getConfiguration()400 inline const PropertyMap& getConfiguration() { return mDevice.getConfiguration(); } 401 402 private: 403 InputDevice& mDevice; 404 InputReaderContext* mContext; 405 EventHubInterface* mEventHub; 406 int32_t mId; 407 int32_t mDeviceId; 408 }; 409 410 } // namespace android 411 412 #endif //_UI_INPUTREADER_INPUT_DEVICE_H 413