Support multiple EventHub devices per InputDevice
Some physical devices contain more functions than can be addressed by
a single Linux evdev device. Examples of such devices are the Sony
DualShock 4 and Wacom Tablets, which appear as multiple evdev devices
sharing the same value for the EVIOCGUNIQ ioctl. As more instances of
such devices hit the market, apps need a way of figuring out which
InputDevices are part of the same physical device.
Per conversation with the android input team, a solution proposed to
this problem is to merge multiple EventHub devices (which have a 1:1
relation with evdev) into a single android InputDevice.
Changes:
Decouple the EventHub device id ("eventHubId") from the InputDevice
device id ("deviceId"). This requires InputDeviceContext to track the
the EventHub devices it represents. Most logic changes are inside
InputDeviceContext, so there are minimal changes to InputMappers.
Added enum value END_RESERVED_ID to represent the first available
id that can be assigned to a normal InputDevice. The android
framework assumes specific values for the virtual keyboard and
built-in hardware keyboard, so for these two cases, the "deviceId"
must match the "eventHubId."
Added "EVENTHUB_ID" constants to tests and changed where applicable.
Cherry-picked from pa/1475694.
Bug: 38511270
Test: atest inputflinger_tests libinput_tests
Change-Id: I89df085fadc1c09bc999599ac5db35c9277c4a2a
diff --git a/services/inputflinger/reader/InputDevice.cpp b/services/inputflinger/reader/InputDevice.cpp
index ae82cd4..d0eee64 100644
--- a/services/inputflinger/reader/InputDevice.cpp
+++ b/services/inputflinger/reader/InputDevice.cpp
@@ -18,6 +18,8 @@
#include "InputDevice.h"
+#include <algorithm>
+
#include "CursorInputMapper.h"
#include "ExternalStylusInputMapper.h"
#include "InputReaderContext.h"
@@ -32,25 +34,28 @@
namespace android {
InputDevice::InputDevice(InputReaderContext* context, int32_t id, int32_t generation,
- int32_t controllerNumber, const InputDeviceIdentifier& identifier,
- uint32_t classes)
+ const InputDeviceIdentifier& identifier)
: mContext(context),
mId(id),
mGeneration(generation),
- mControllerNumber(controllerNumber),
+ mControllerNumber(0),
mIdentifier(identifier),
- mClasses(classes),
+ mClasses(0),
mSources(0),
mIsExternal(false),
mHasMic(false),
- mDropUntilNextSync(false) {
- mDeviceContext = std::make_unique<InputDeviceContext>(*this);
-}
+ mDropUntilNextSync(false) {}
InputDevice::~InputDevice() {}
bool InputDevice::isEnabled() {
- return mDeviceContext->isDeviceEnabled();
+ if (!hasEventHubDevices()) {
+ return false;
+ }
+ // devices are either all enabled or all disabled, so we only need to check the first
+ auto& devicePair = mDevices.begin()->second;
+ auto& contextPtr = devicePair.first;
+ return contextPtr->isDeviceEnabled();
}
void InputDevice::setEnabled(bool enabled, nsecs_t when) {
@@ -65,12 +70,15 @@
return;
}
+ // When resetting some devices, the driver needs to be queried to ensure that a proper reset is
+ // performed. The querying must happen when the device is enabled, so we reset after enabling
+ // but before disabling the device. See MultiTouchMotionAccumulator::reset for more information.
if (enabled) {
- mDeviceContext->enableDevice();
+ for_each_subdevice([](auto& context) { context.enableDevice(); });
reset(when);
} else {
reset(when);
- mDeviceContext->disableDevice();
+ for_each_subdevice([](auto& context) { context.disableDevice(); });
}
// Must change generation to flag this device as changed
bumpGeneration();
@@ -118,19 +126,18 @@
for_each_mapper([&dump](InputMapper& mapper) { mapper.dump(dump); });
}
-void InputDevice::populateMappers() {
- uint32_t classes = mClasses;
- std::vector<std::unique_ptr<InputMapper>>& mappers = mMappers;
- std::unique_ptr<InputDeviceContext>& contextPtr = mDeviceContext;
-
- // External devices.
- if (classes & INPUT_DEVICE_CLASS_EXTERNAL) {
- setExternal(true);
+void InputDevice::addEventHubDevice(int32_t eventHubId, bool populateMappers) {
+ if (mDevices.find(eventHubId) != mDevices.end()) {
+ return;
}
+ std::unique_ptr<InputDeviceContext> contextPtr(new InputDeviceContext(*this, eventHubId));
+ uint32_t classes = contextPtr->getDeviceClasses();
+ std::vector<std::unique_ptr<InputMapper>> mappers;
- // Devices with mics.
- if (classes & INPUT_DEVICE_CLASS_MIC) {
- setMic(true);
+ // Check if we should skip population
+ if (!populateMappers) {
+ mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});
+ return;
}
// Switch-like devices.
@@ -190,22 +197,58 @@
if (classes & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
mappers.push_back(std::make_unique<ExternalStylusInputMapper>(*contextPtr));
}
+
+ // insert the context into the devices set
+ mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});
+}
+
+void InputDevice::removeEventHubDevice(int32_t eventHubId) {
+ mDevices.erase(eventHubId);
}
void InputDevice::configure(nsecs_t when, const InputReaderConfiguration* config,
uint32_t changes) {
mSources = 0;
+ mClasses = 0;
+ mControllerNumber = 0;
+
+ for_each_subdevice([this](InputDeviceContext& context) {
+ mClasses |= context.getDeviceClasses();
+ int32_t controllerNumber = context.getDeviceControllerNumber();
+ if (controllerNumber > 0) {
+ if (mControllerNumber && mControllerNumber != controllerNumber) {
+ ALOGW("InputDevice::configure(): composite device contains multiple unique "
+ "controller numbers");
+ }
+ mControllerNumber = controllerNumber;
+ }
+ });
+
+ mIsExternal = !!(mClasses & INPUT_DEVICE_CLASS_EXTERNAL);
+ mHasMic = !!(mClasses & INPUT_DEVICE_CLASS_MIC);
if (!isIgnored()) {
if (!changes) { // first time only
- mDeviceContext->getConfiguration(&mConfiguration);
+ mConfiguration.clear();
+ for_each_subdevice([this](InputDeviceContext& context) {
+ PropertyMap configuration;
+ context.getConfiguration(&configuration);
+ mConfiguration.addAll(&configuration);
+ });
}
if (!changes || (changes & InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS)) {
if (!(mClasses & INPUT_DEVICE_CLASS_VIRTUAL)) {
sp<KeyCharacterMap> keyboardLayout =
mContext->getPolicy()->getKeyboardLayoutOverlay(mIdentifier);
- if (mDeviceContext->setKeyboardLayoutOverlay(keyboardLayout)) {
+ bool shouldBumpGeneration = false;
+ for_each_subdevice(
+ [&keyboardLayout, &shouldBumpGeneration](InputDeviceContext& context) {
+ if (context.setKeyboardLayoutOverlay(keyboardLayout)) {
+ shouldBumpGeneration = true;
+ }
+ });
+ if (shouldBumpGeneration) {
bumpGeneration();
}
}
@@ -313,7 +356,9 @@
mDropUntilNextSync = true;
reset(rawEvent->when);
} else {
- for_each_mapper([rawEvent](InputMapper& mapper) { mapper.process(rawEvent); });
+ for_each_mapper_in_subdevice(rawEvent->deviceId, [rawEvent](InputMapper& mapper) {
+ mapper.process(rawEvent);
+ });
}
--count;
}
@@ -348,16 +393,20 @@
int32_t InputDevice::getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc) {
int32_t result = AKEY_STATE_UNKNOWN;
- for (auto& mapperPtr : mMappers) {
- InputMapper& mapper = *mapperPtr;
- if (sourcesMatchMask(mapper.getSources(), sourceMask)) {
- // If any mapper reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that
- // value. Otherwise, return AKEY_STATE_UP as long as one mapper reports it.
- int32_t currentResult = (mapper.*getStateFunc)(sourceMask, code);
- if (currentResult >= AKEY_STATE_DOWN) {
- return currentResult;
- } else if (currentResult == AKEY_STATE_UP) {
- result = currentResult;
+ for (auto& deviceEntry : mDevices) {
+ auto& devicePair = deviceEntry.second;
+ auto& mappers = devicePair.second;
+ for (auto& mapperPtr : mappers) {
+ InputMapper& mapper = *mapperPtr;
+ if (sourcesMatchMask(mapper.getSources(), sourceMask)) {
+ // If any mapper reports AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL, return that
+ // value. Otherwise, return AKEY_STATE_UP as long as one mapper reports it.
+ int32_t currentResult = (mapper.*getStateFunc)(sourceMask, code);
+ if (currentResult >= AKEY_STATE_DOWN) {
+ return currentResult;
+ } else if (currentResult == AKEY_STATE_UP) {
+ result = currentResult;
+ }
}
}
}
@@ -424,11 +473,23 @@
[](InputMapper& mapper) { return mapper.getAssociatedDisplayId(); });
}
-InputDeviceContext::InputDeviceContext(InputDevice& device)
+// returns the number of mappers associated with the device
+size_t InputDevice::getMapperCount() {
+ size_t count = 0;
+ for (auto& deviceEntry : mDevices) {
+ auto& devicePair = deviceEntry.second;
+ auto& mappers = devicePair.second;
+ count += mappers.size();
+ }
+ return count;
+}
+
+InputDeviceContext::InputDeviceContext(InputDevice& device, int32_t eventHubId)
: mDevice(device),
mContext(device.getContext()),
mEventHub(device.getContext()->getEventHub()),
- mId(device.getId()) {}
+ mId(eventHubId),
+ mDeviceId(device.getId()) {}
InputDeviceContext::~InputDeviceContext() {}
diff --git a/services/inputflinger/reader/InputReader.cpp b/services/inputflinger/reader/InputReader.cpp
index 8327ed8..cbfa702 100644
--- a/services/inputflinger/reader/InputReader.cpp
+++ b/services/inputflinger/reader/InputReader.cpp
@@ -49,6 +49,7 @@
mNextSequenceNum(1),
mGlobalMetaState(0),
mGeneration(1),
+ mNextInputDeviceId(END_RESERVED_ID),
mDisableVirtualKeysTimeout(LLONG_MIN),
mNextTimeout(LLONG_MAX),
mConfigurationChangesToRefresh(0) {
@@ -184,30 +185,28 @@
}
}
-void InputReader::addDeviceLocked(nsecs_t when, int32_t deviceId) {
- if (mDevices.find(deviceId) != mDevices.end()) {
- ALOGW("Ignoring spurious device added event for deviceId %d.", deviceId);
+void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) {
+ if (mDevices.find(eventHubId) != mDevices.end()) {
+ ALOGW("Ignoring spurious device added event for eventHubId %d.", eventHubId);
return;
}
- InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(deviceId);
- uint32_t classes = mEventHub->getDeviceClasses(deviceId);
- int32_t controllerNumber = mEventHub->getDeviceControllerNumber(deviceId);
-
- std::shared_ptr<InputDevice> device =
- createDeviceLocked(deviceId, controllerNumber, identifier, classes);
+ InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(eventHubId);
+ std::shared_ptr<InputDevice> device = createDeviceLocked(eventHubId, identifier);
device->configure(when, &mConfig, 0);
device->reset(when);
if (device->isIgnored()) {
- ALOGI("Device added: id=%d, name='%s' (ignored non-input device)", deviceId,
- identifier.name.c_str());
+ ALOGI("Device added: id=%d, eventHubId=%d, name='%s', descriptor='%s' "
+ "(ignored non-input device)",
+ device->getId(), eventHubId, identifier.name.c_str(), identifier.descriptor.c_str());
} else {
- ALOGI("Device added: id=%d, name='%s', sources=0x%08x", deviceId, identifier.name.c_str(),
+ ALOGI("Device added: id=%d, eventHubId=%d, name='%s', descriptor='%s',sources=0x%08x",
+ device->getId(), eventHubId, identifier.name.c_str(), identifier.descriptor.c_str(),
device->getSources());
}
- mDevices.emplace(deviceId, device);
+ mDevices.emplace(eventHubId, device);
bumpGenerationLocked();
if (device->getClasses() & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
@@ -215,10 +214,10 @@
}
}
-void InputReader::removeDeviceLocked(nsecs_t when, int32_t deviceId) {
- auto deviceIt = mDevices.find(deviceId);
+void InputReader::removeDeviceLocked(nsecs_t when, int32_t eventHubId) {
+ auto deviceIt = mDevices.find(eventHubId);
if (deviceIt == mDevices.end()) {
- ALOGW("Ignoring spurious device removed event for deviceId %d.", deviceId);
+ ALOGW("Ignoring spurious device removed event for eventHubId %d.", eventHubId);
return;
}
@@ -227,35 +226,52 @@
bumpGenerationLocked();
if (device->isIgnored()) {
- ALOGI("Device removed: id=%d, name='%s' (ignored non-input device)", device->getId(),
- device->getName().c_str());
+ ALOGI("Device removed: id=%d, eventHubId=%d, name='%s', descriptor='%s' "
+ "(ignored non-input device)",
+ device->getId(), eventHubId, device->getName().c_str(),
+ device->getDescriptor().c_str());
} else {
- ALOGI("Device removed: id=%d, name='%s', sources=0x%08x", device->getId(),
- device->getName().c_str(), device->getSources());
+ ALOGI("Device removed: id=%d, eventHubId=%d, name='%s', descriptor='%s', sources=0x%08x",
+ device->getId(), eventHubId, device->getName().c_str(),
+ device->getDescriptor().c_str(), device->getSources());
}
+ device->removeEventHubDevice(eventHubId);
+
if (device->getClasses() & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
notifyExternalStylusPresenceChanged();
}
+ if (device->hasEventHubDevices()) {
+ device->configure(when, &mConfig, 0);
+ }
device->reset(when);
}
std::shared_ptr<InputDevice> InputReader::createDeviceLocked(
- int32_t deviceId, int32_t controllerNumber, const InputDeviceIdentifier& identifier,
- uint32_t classes) {
- std::shared_ptr<InputDevice> device =
- std::make_shared<InputDevice>(&mContext, deviceId, bumpGenerationLocked(),
- controllerNumber, identifier, classes);
- device->populateMappers();
+ int32_t eventHubId, const InputDeviceIdentifier& identifier) {
+ auto deviceIt = std::find_if(mDevices.begin(), mDevices.end(), [identifier](auto& devicePair) {
+ return devicePair.second->getDescriptor().size() && identifier.descriptor.size() &&
+ devicePair.second->getDescriptor() == identifier.descriptor;
+ });
+
+ std::shared_ptr<InputDevice> device;
+ if (deviceIt != mDevices.end()) {
+ device = deviceIt->second;
+ } else {
+ int32_t deviceId = (eventHubId < END_RESERVED_ID) ? eventHubId : nextInputDeviceIdLocked();
+ device = std::make_shared<InputDevice>(&mContext, deviceId, bumpGenerationLocked(),
+ identifier);
+ }
+ device->addEventHubDevice(eventHubId);
return device;
}
-void InputReader::processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents,
+void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents,
size_t count) {
- auto deviceIt = mDevices.find(deviceId);
+ auto deviceIt = mDevices.find(eventHubId);
if (deviceIt == mDevices.end()) {
- ALOGW("Discarding event for unknown deviceId %d.", deviceId);
+ ALOGW("Discarding event for unknown eventHubId %d.", eventHubId);
return;
}
@@ -268,6 +284,17 @@
device->process(rawEvents, count);
}
+InputDevice* InputReader::findInputDevice(int32_t deviceId) {
+ auto deviceIt =
+ std::find_if(mDevices.begin(), mDevices.end(), [deviceId](const auto& devicePair) {
+ return devicePair.second->getId() == deviceId;
+ });
+ if (deviceIt != mDevices.end()) {
+ return deviceIt->second.get();
+ }
+ return nullptr;
+}
+
void InputReader::timeoutExpiredLocked(nsecs_t when) {
for (auto& devicePair : mDevices) {
std::shared_ptr<InputDevice>& device = devicePair.second;
@@ -277,6 +304,10 @@
}
}
+int32_t InputReader::nextInputDeviceIdLocked() {
+ return ++mNextInputDeviceId;
+}
+
void InputReader::handleConfigurationChangedLocked(nsecs_t when) {
// Reset global meta state because it depends on the list of all configured devices.
updateGlobalMetaStateLocked();
@@ -414,12 +445,9 @@
GetStateFunc getStateFunc) {
int32_t result = AKEY_STATE_UNKNOWN;
if (deviceId >= 0) {
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt != mDevices.end()) {
- std::shared_ptr<InputDevice>& device = deviceIt->second;
- if (!device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
- result = (device.get()->*getStateFunc)(sourceMask, code);
- }
+ InputDevice* device = findInputDevice(deviceId);
+ if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
+ result = (device->*getStateFunc)(sourceMask, code);
}
} else {
for (auto& devicePair : mDevices) {
@@ -440,13 +468,12 @@
}
void InputReader::toggleCapsLockState(int32_t deviceId) {
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt == mDevices.end()) {
+ InputDevice* device = findInputDevice(deviceId);
+ if (!device) {
ALOGW("Ignoring toggleCapsLock for unknown deviceId %" PRId32 ".", deviceId);
return;
}
- std::shared_ptr<InputDevice>& device = deviceIt->second;
if (device->isIgnored()) {
return;
}
@@ -467,12 +494,9 @@
uint8_t* outFlags) {
bool result = false;
if (deviceId >= 0) {
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt != mDevices.end()) {
- std::shared_ptr<InputDevice>& device = deviceIt->second;
- if (!device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
- result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);
- }
+ InputDevice* device = findInputDevice(deviceId);
+ if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
+ result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);
}
} else {
for (auto& devicePair : mDevices) {
@@ -501,9 +525,8 @@
void InputReader::vibrate(int32_t deviceId, const nsecs_t* pattern, size_t patternSize,
ssize_t repeat, int32_t token) {
AutoMutex _l(mLock);
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt != mDevices.end()) {
- std::shared_ptr<InputDevice>& device = deviceIt->second;
+ InputDevice* device = findInputDevice(deviceId);
+ if (device) {
device->vibrate(pattern, patternSize, repeat, token);
}
}
@@ -511,9 +534,8 @@
void InputReader::cancelVibrate(int32_t deviceId, int32_t token) {
AutoMutex _l(mLock);
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt != mDevices.end()) {
- std::shared_ptr<InputDevice>& device = deviceIt->second;
+ InputDevice* device = findInputDevice(deviceId);
+ if (device) {
device->cancelVibrate(token);
}
}
@@ -521,9 +543,8 @@
bool InputReader::isInputDeviceEnabled(int32_t deviceId) {
AutoMutex _l(mLock);
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt != mDevices.end()) {
- std::shared_ptr<InputDevice>& device = deviceIt->second;
+ InputDevice* device = findInputDevice(deviceId);
+ if (device) {
return device->isEnabled();
}
ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);
@@ -533,13 +554,12 @@
bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {
AutoMutex _l(mLock);
- auto deviceIt = mDevices.find(deviceId);
- if (deviceIt == mDevices.end()) {
+ InputDevice* device = findInputDevice(deviceId);
+ if (!device) {
ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);
return false;
}
- std::shared_ptr<InputDevice>& device = deviceIt->second;
if (!device->isEnabled()) {
ALOGW("Ignoring disabled device %s", device->getName().c_str());
return false;
diff --git a/services/inputflinger/reader/include/InputDevice.h b/services/inputflinger/reader/include/InputDevice.h
index 0814d1f..aaa0d26 100644
--- a/services/inputflinger/reader/include/InputDevice.h
+++ b/services/inputflinger/reader/include/InputDevice.h
@@ -17,18 +17,19 @@
#ifndef _UI_INPUTREADER_INPUT_DEVICE_H
#define _UI_INPUTREADER_INPUT_DEVICE_H
+#include <input/DisplayViewport.h>
+#include <input/InputDevice.h>
+#include <stdint.h>
+#include <utils/PropertyMap.h>
+
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
#include "EventHub.h"
#include "InputReaderBase.h"
#include "InputReaderContext.h"
-#include <input/DisplayViewport.h>
-#include <input/InputDevice.h>
-#include <utils/PropertyMap.h>
-
-#include <stdint.h>
-#include <optional>
-#include <vector>
-
namespace android {
class InputDeviceContext;
@@ -38,8 +39,7 @@
class InputDevice {
public:
InputDevice(InputReaderContext* context, int32_t id, int32_t generation,
- int32_t controllerNumber, const InputDeviceIdentifier& identifier,
- uint32_t classes);
+ const InputDeviceIdentifier& identifier);
~InputDevice();
inline InputReaderContext* getContext() { return mContext; }
@@ -50,25 +50,25 @@
inline const std::string getDescriptor() { return mIdentifier.descriptor; }
inline uint32_t getClasses() const { return mClasses; }
inline uint32_t getSources() const { return mSources; }
+ inline bool hasEventHubDevices() const { return !mDevices.empty(); }
inline bool isExternal() { return mIsExternal; }
- inline void setExternal(bool external) { mIsExternal = external; }
inline std::optional<uint8_t> getAssociatedDisplayPort() const {
return mAssociatedDisplayPort;
}
inline std::optional<DisplayViewport> getAssociatedViewport() const {
return mAssociatedViewport;
}
- inline void setMic(bool hasMic) { mHasMic = hasMic; }
inline bool hasMic() const { return mHasMic; }
- inline bool isIgnored() { return mMappers.empty(); }
+ inline bool isIgnored() { return !getMapperCount(); }
bool isEnabled();
void setEnabled(bool enabled, nsecs_t when);
void dump(std::string& dump);
- void populateMappers();
+ void addEventHubDevice(int32_t eventHubId, bool populateMappers = true);
+ void removeEventHubDevice(int32_t eventHubId);
void configure(nsecs_t when, const InputReaderConfiguration* config, uint32_t changes);
void reset(nsecs_t when);
void process(const RawEvent* rawEvents, size_t count);
@@ -99,11 +99,20 @@
std::optional<int32_t> getAssociatedDisplayId();
+ size_t getMapperCount();
+
// construct and add a mapper to the input device
template <class T, typename... Args>
- T& addMapper(Args... args) {
- T* mapper = new T(*mDeviceContext, args...);
- mMappers.emplace_back(mapper);
+ T& addMapper(int32_t eventHubId, Args... args) {
+ // ensure a device entry exists for this eventHubId
+ addEventHubDevice(eventHubId, false);
+
+ // create mapper
+ auto& devicePair = mDevices[eventHubId];
+ auto& deviceContext = devicePair.first;
+ auto& mappers = devicePair.second;
+ T* mapper = new T(*deviceContext, args...);
+ mappers.emplace_back(mapper);
return *mapper;
}
@@ -116,8 +125,10 @@
std::string mAlias;
uint32_t mClasses;
- std::unique_ptr<InputDeviceContext> mDeviceContext;
- std::vector<std::unique_ptr<InputMapper>> mMappers;
+ // map from eventHubId to device context and mappers
+ using MapperVector = std::vector<std::unique_ptr<InputMapper>>;
+ using DevicePair = std::pair<std::unique_ptr<InputDeviceContext>, MapperVector>;
+ std::unordered_map<int32_t, DevicePair> mDevices;
uint32_t mSources;
bool mIsExternal;
@@ -131,10 +142,37 @@
PropertyMap mConfiguration;
- // run a function against every mapper
+ // helpers to interate over the devices collection
+ // run a function against every mapper on every subdevice
inline void for_each_mapper(std::function<void(InputMapper&)> f) {
- for (auto& mapperPtr : mMappers) {
- f(*mapperPtr);
+ for (auto& deviceEntry : mDevices) {
+ auto& devicePair = deviceEntry.second;
+ auto& mappers = devicePair.second;
+ for (auto& mapperPtr : mappers) {
+ f(*mapperPtr);
+ }
+ }
+ }
+
+ // run a function against every mapper on a specific subdevice
+ inline void for_each_mapper_in_subdevice(int32_t eventHubDevice,
+ std::function<void(InputMapper&)> f) {
+ auto deviceIt = mDevices.find(eventHubDevice);
+ if (deviceIt != mDevices.end()) {
+ auto& devicePair = deviceIt->second;
+ auto& mappers = devicePair.second;
+ for (auto& mapperPtr : mappers) {
+ f(*mapperPtr);
+ }
+ }
+ }
+
+ // run a function against every subdevice
+ inline void for_each_subdevice(std::function<void(InputDeviceContext&)> f) {
+ for (auto& deviceEntry : mDevices) {
+ auto& devicePair = deviceEntry.second;
+ auto& contextPtr = devicePair.first;
+ f(*contextPtr);
}
}
@@ -142,10 +180,14 @@
// if all mappers return nullopt, return nullopt.
template <typename T>
inline std::optional<T> first_in_mappers(std::function<std::optional<T>(InputMapper&)> f) {
- for (auto& mapperPtr : mMappers) {
- std::optional<T> ret = f(*mapperPtr);
- if (ret) {
- return ret;
+ for (auto& deviceEntry : mDevices) {
+ auto& devicePair = deviceEntry.second;
+ auto& mappers = devicePair.second;
+ for (auto& mapperPtr : mappers) {
+ std::optional<T> ret = f(*mapperPtr);
+ if (ret) {
+ return ret;
+ }
}
}
return std::nullopt;
@@ -159,11 +201,12 @@
*/
class InputDeviceContext {
public:
- InputDeviceContext(InputDevice& device);
+ InputDeviceContext(InputDevice& device, int32_t eventHubId);
~InputDeviceContext();
inline InputReaderContext* getContext() { return mContext; }
- inline int32_t getId() { return mId; }
+ inline int32_t getId() { return mDeviceId; }
+ inline int32_t getEventHubId() { return mId; }
inline uint32_t getDeviceClasses() const { return mEventHub->getDeviceClasses(mId); }
inline InputDeviceIdentifier getDeviceIdentifier() const {
@@ -259,6 +302,7 @@
InputReaderContext* mContext;
EventHubInterface* mEventHub;
int32_t mId;
+ int32_t mDeviceId;
};
} // namespace android
diff --git a/services/inputflinger/reader/include/InputReader.h b/services/inputflinger/reader/include/InputReader.h
index 4f5d2ea..31d82f1 100644
--- a/services/inputflinger/reader/include/InputReader.h
+++ b/services/inputflinger/reader/include/InputReader.h
@@ -84,10 +84,8 @@
protected:
// These members are protected so they can be instrumented by test cases.
- virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t deviceId,
- int32_t controllerNumber,
- const InputDeviceIdentifier& identifier,
- uint32_t classes);
+ virtual std::shared_ptr<InputDevice> createDeviceLocked(
+ int32_t deviceId, const InputDeviceIdentifier& identifier);
// With each iteration of the loop, InputReader reads and processes one incoming message from
// the EventHub.
@@ -139,14 +137,16 @@
static const int EVENT_BUFFER_SIZE = 256;
RawEvent mEventBuffer[EVENT_BUFFER_SIZE];
- std::unordered_map<int32_t /*deviceId*/, std::shared_ptr<InputDevice>> mDevices;
+ // An input device can represent a collection of EventHub devices. This map provides a way
+ // to lookup the input device instance from the EventHub device id.
+ std::unordered_map<int32_t /*eventHubId*/, std::shared_ptr<InputDevice>> mDevices;
// low-level input event decoding and device management
void processEventsLocked(const RawEvent* rawEvents, size_t count);
- void addDeviceLocked(nsecs_t when, int32_t deviceId);
- void removeDeviceLocked(nsecs_t when, int32_t deviceId);
- void processEventsForDeviceLocked(int32_t deviceId, const RawEvent* rawEvents, size_t count);
+ void addDeviceLocked(nsecs_t when, int32_t eventHubId);
+ void removeDeviceLocked(nsecs_t when, int32_t eventHubId);
+ void processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents, size_t count);
void timeoutExpiredLocked(nsecs_t when);
void handleConfigurationChangedLocked(nsecs_t when);
@@ -164,6 +164,9 @@
int32_t mGeneration;
int32_t bumpGenerationLocked();
+ int32_t mNextInputDeviceId;
+ int32_t nextInputDeviceIdLocked();
+
void getInputDevicesLocked(std::vector<InputDeviceInfo>& outInputDevices);
nsecs_t mDisableVirtualKeysTimeout;
@@ -182,6 +185,9 @@
GetStateFunc getStateFunc);
bool markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
const int32_t* keyCodes, uint8_t* outFlags);
+
+ // find an InputDevice from an InputDevice id
+ InputDevice* findInputDevice(int32_t deviceId);
};
} // namespace android