Refactor use of services in InputMappers.
Create InputDeviceContext class to hide direct EventHub and
InputDevice accesses from InputMappers.
Test: atest inputflinger_tests libinput_tests
Change-Id: I05f9c808fc1a6f4c9207bd29fde50b76ec5655bb
diff --git a/services/inputflinger/reader/include/InputDevice.h b/services/inputflinger/reader/include/InputDevice.h
index d06cc20..0814d1f 100644
--- a/services/inputflinger/reader/include/InputDevice.h
+++ b/services/inputflinger/reader/include/InputDevice.h
@@ -31,6 +31,7 @@
namespace android {
+class InputDeviceContext;
class InputMapper;
/* Represents the state of a single input device. */
@@ -96,30 +97,12 @@
inline const PropertyMap& getConfiguration() { return mConfiguration; }
inline EventHubInterface* getEventHub() { return mContext->getEventHub(); }
- bool hasKey(int32_t code) { return getEventHub()->hasScanCode(mId, code); }
-
- bool hasAbsoluteAxis(int32_t code) {
- RawAbsoluteAxisInfo info;
- getEventHub()->getAbsoluteAxisInfo(mId, code, &info);
- return info.valid;
- }
-
- bool isKeyPressed(int32_t code) {
- return getEventHub()->getScanCodeState(mId, code) == AKEY_STATE_DOWN;
- }
-
- int32_t getAbsoluteAxisValue(int32_t code) {
- int32_t value;
- getEventHub()->getAbsoluteAxisValue(mId, code, &value);
- return value;
- }
-
std::optional<int32_t> getAssociatedDisplayId();
// construct and add a mapper to the input device
template <class T, typename... Args>
T& addMapper(Args... args) {
- T* mapper = new T(this, args...);
+ T* mapper = new T(*mDeviceContext, args...);
mMappers.emplace_back(mapper);
return *mapper;
}
@@ -133,6 +116,7 @@
std::string mAlias;
uint32_t mClasses;
+ std::unique_ptr<InputDeviceContext> mDeviceContext;
std::vector<std::unique_ptr<InputMapper>> mMappers;
uint32_t mSources;
@@ -168,6 +152,115 @@
}
};
+/* Provides access to EventHub methods, but limits access to the current InputDevice.
+ * Essentially an implementation of EventHubInterface, but for a specific device id.
+ * Helps hide implementation details of InputDevice and EventHub. Used by mappers to
+ * check the status of the associated hardware device
+ */
+class InputDeviceContext {
+public:
+ InputDeviceContext(InputDevice& device);
+ ~InputDeviceContext();
+
+ inline InputReaderContext* getContext() { return mContext; }
+ inline int32_t getId() { return mId; }
+
+ inline uint32_t getDeviceClasses() const { return mEventHub->getDeviceClasses(mId); }
+ inline InputDeviceIdentifier getDeviceIdentifier() const {
+ return mEventHub->getDeviceIdentifier(mId);
+ }
+ inline int32_t getDeviceControllerNumber() const {
+ return mEventHub->getDeviceControllerNumber(mId);
+ }
+ inline void getConfiguration(PropertyMap* outConfiguration) const {
+ return mEventHub->getConfiguration(mId, outConfiguration);
+ }
+ inline status_t getAbsoluteAxisInfo(int32_t code, RawAbsoluteAxisInfo* axisInfo) const {
+ return mEventHub->getAbsoluteAxisInfo(mId, code, axisInfo);
+ }
+ inline bool hasRelativeAxis(int32_t code) const {
+ return mEventHub->hasRelativeAxis(mId, code);
+ }
+ inline bool hasInputProperty(int property) const {
+ return mEventHub->hasInputProperty(mId, property);
+ }
+ inline status_t mapKey(int32_t scanCode, int32_t usageCode, int32_t metaState,
+ int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
+ return mEventHub->mapKey(mId, scanCode, usageCode, metaState, outKeycode, outMetaState,
+ outFlags);
+ }
+ inline status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const {
+ return mEventHub->mapAxis(mId, scanCode, outAxisInfo);
+ }
+ inline std::vector<TouchVideoFrame> getVideoFrames() { return mEventHub->getVideoFrames(mId); }
+ inline int32_t getScanCodeState(int32_t scanCode) const {
+ return mEventHub->getScanCodeState(mId, scanCode);
+ }
+ inline int32_t getKeyCodeState(int32_t keyCode) const {
+ return mEventHub->getKeyCodeState(mId, keyCode);
+ }
+ inline int32_t getSwitchState(int32_t sw) const { return mEventHub->getSwitchState(mId, sw); }
+ inline status_t getAbsoluteAxisValue(int32_t code, int32_t* outValue) const {
+ return mEventHub->getAbsoluteAxisValue(mId, code, outValue);
+ }
+ inline bool markSupportedKeyCodes(size_t numCodes, const int32_t* keyCodes,
+ uint8_t* outFlags) const {
+ return mEventHub->markSupportedKeyCodes(mId, numCodes, keyCodes, outFlags);
+ }
+ inline bool hasScanCode(int32_t scanCode) const {
+ return mEventHub->hasScanCode(mId, scanCode);
+ }
+ inline bool hasLed(int32_t led) const { return mEventHub->hasLed(mId, led); }
+ inline void setLedState(int32_t led, bool on) { return mEventHub->setLedState(mId, led, on); }
+ inline void getVirtualKeyDefinitions(std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
+ return mEventHub->getVirtualKeyDefinitions(mId, outVirtualKeys);
+ }
+ inline sp<KeyCharacterMap> getKeyCharacterMap() const {
+ return mEventHub->getKeyCharacterMap(mId);
+ }
+ inline bool setKeyboardLayoutOverlay(const sp<KeyCharacterMap>& map) {
+ return mEventHub->setKeyboardLayoutOverlay(mId, map);
+ }
+ inline void vibrate(nsecs_t duration) { return mEventHub->vibrate(mId, duration); }
+ inline void cancelVibrate() { return mEventHub->cancelVibrate(mId); }
+
+ inline bool hasAbsoluteAxis(int32_t code) const {
+ RawAbsoluteAxisInfo info;
+ mEventHub->getAbsoluteAxisInfo(mId, code, &info);
+ return info.valid;
+ }
+ inline bool isKeyPressed(int32_t code) const {
+ return mEventHub->getScanCodeState(mId, code) == AKEY_STATE_DOWN;
+ }
+ inline int32_t getAbsoluteAxisValue(int32_t code) const {
+ int32_t value;
+ mEventHub->getAbsoluteAxisValue(mId, code, &value);
+ return value;
+ }
+ inline bool isDeviceEnabled() { return mEventHub->isDeviceEnabled(mId); }
+ inline status_t enableDevice() { return mEventHub->enableDevice(mId); }
+ inline status_t disableDevice() { return mEventHub->disableDevice(mId); }
+
+ inline const std::string getName() { return mDevice.getName(); }
+ inline const std::string getDescriptor() { return mDevice.getDescriptor(); }
+ inline bool isExternal() { return mDevice.isExternal(); }
+ inline std::optional<uint8_t> getAssociatedDisplayPort() const {
+ return mDevice.getAssociatedDisplayPort();
+ }
+ inline std::optional<DisplayViewport> getAssociatedViewport() const {
+ return mDevice.getAssociatedViewport();
+ }
+ inline void cancelTouch(nsecs_t when) { mDevice.cancelTouch(when); }
+ inline void bumpGeneration() { mDevice.bumpGeneration(); }
+ inline const PropertyMap& getConfiguration() { return mDevice.getConfiguration(); }
+
+private:
+ InputDevice& mDevice;
+ InputReaderContext* mContext;
+ EventHubInterface* mEventHub;
+ int32_t mId;
+};
+
} // namespace android
#endif //_UI_INPUTREADER_INPUT_DEVICE_H