Merge "Get Input device information in locked context" (5f409a06) · Commits · e / os / android_frameworks_native-old

services/inputflinger/reader/EventHub.cpp

+31 −32

Original line number	Diff line number	Diff line
		@@ -475,25 +475,25 @@ EventHub::~EventHub(void) {
		}

		InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		return device != nullptr ? device->identifier : InputDeviceIdentifier();
		}

		Flags<InputDeviceClass> EventHub::getDeviceClasses(int32_t deviceId) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		return device != nullptr ? device->classes : Flags<InputDeviceClass>(0);
		}

		int32_t EventHub::getDeviceControllerNumber(int32_t deviceId) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		return device != nullptr ? device->controllerNumber : 0;
		}

		void EventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->configuration) {
		outConfiguration = device->configuration;
		@@ -507,7 +507,7 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
		outAxisInfo->clear();

		if (axis >= 0 && axis <= ABS_MAX) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
		@@ -534,7 +534,7 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,

		bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
		if (axis >= 0 && axis <= REL_MAX) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		return device != nullptr ? device->relBitmask.test(axis) : false;
		}
		@@ -542,7 +542,7 @@ bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
		}

		bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr
		@@ -552,7 +552,7 @@ bool EventHub::hasInputProperty(int32_t deviceId, int property) const {

		int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
		if (scanCode >= 0 && scanCode <= KEY_MAX) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) {
		@@ -565,7 +565,7 @@ int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
		}

		int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) {
		@@ -588,7 +588,7 @@ int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {

		int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
		if (sw >= 0 && sw <= SW_MAX) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) {
		@@ -604,7 +604,7 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t*
		*outValue = 0;

		if (axis >= 0 && axis <= ABS_MAX) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
		@@ -624,7 +624,7 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t*

		bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
		uint8_t* outFlags) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->keyMap.haveKeyLayout()) {
		@@ -652,7 +652,7 @@ bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const in

		status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
		int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		status_t status = NAME_NOT_FOUND;

		@@ -692,7 +692,7 @@ status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
		}

		status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);

		if (device != nullptr && device->keyMap.haveKeyLayout()) {
		@@ -706,13 +706,13 @@ status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxis
		}

		void EventHub::setExcludedDevices(const std::vector<std::string>& devices) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		mExcludedDevices = devices;
		}

		bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {
		return device->keyBitmask.test(scanCode);
		@@ -721,7 +721,7 @@ bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
		}

		bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		int32_t sc;
		if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) {
		@@ -731,7 +731,7 @@ bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
		}

		void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd()) {
		device->setLedStateLocked(led, on);
		@@ -742,7 +742,7 @@ void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
		std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
		outVirtualKeys.clear();

		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->virtualKeyMap) {
		const std::vector<VirtualKeyDefinition> virtualKeys =
		@@ -752,7 +752,7 @@ void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
		}

		const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr) {
		return device->getKeyCharacterMap();
		@@ -761,7 +761,7 @@ const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t devi
		}

		bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId, std::shared_ptr<KeyCharacterMap> map) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && map != nullptr && device->keyMap.keyCharacterMap != nullptr) {
		device->keyMap.keyCharacterMap->combine(*map);
		@@ -822,7 +822,7 @@ void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) {
		}

		void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd()) {
		ff_effect effect;
		@@ -857,7 +857,7 @@ void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) {
		}

		void EventHub::cancelVibrate(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device != nullptr && device->hasValidFd()) {
		if (device->ffEffectPlaying) {
		@@ -930,7 +930,7 @@ EventHub::Device* EventHub::getDeviceByFdLocked(int fd) const {
		size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
		ALOG_ASSERT(bufferSize >= 1);

		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		struct input_event readBuffer[bufferSize];

		@@ -1184,7 +1184,7 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		}

		std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		Device* device = getDeviceLocked(deviceId);
		if (device == nullptr \|\| !device->videoDevice) {
		@@ -1593,7 +1593,7 @@ bool EventHub::tryAddVideoDevice(EventHub::Device& device,
		}

		bool EventHub::isDeviceEnabled(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device == nullptr) {
		ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
		@@ -1603,7 +1603,7 @@ bool EventHub::isDeviceEnabled(int32_t deviceId) {
		}

		status_t EventHub::enableDevice(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device == nullptr) {
		ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
		@@ -1625,7 +1625,7 @@ status_t EventHub::enableDevice(int32_t deviceId) {
		}

		status_t EventHub::disableDevice(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		Device* device = getDeviceLocked(deviceId);
		if (device == nullptr) {
		ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
		@@ -1809,7 +1809,7 @@ status_t EventHub::scanVideoDirLocked(const std::string& dirname) {
		void EventHub::requestReopenDevices() {
		ALOGV("requestReopenDevices() called");

		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		mNeedToReopenDevices = true;
		}

		@@ -1817,7 +1817,7 @@ void EventHub::dump(std::string& dump) {
		dump += "Event Hub State:\n";

		{ // acquire lock
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		dump += StringPrintf(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);

		@@ -1868,8 +1868,7 @@ void EventHub::dump(std::string& dump) {

		void EventHub::monitor() {
		// Acquire and release the lock to ensure that the event hub has not deadlocked.
		mLock.lock();
		mLock.unlock();
		std::unique_lock<std::mutex> lock(mLock);
		}

		}; // namespace android

services/inputflinger/reader/InputReader.cpp

+33 −31

Original line number	Diff line number	Diff line
		@@ -56,7 +56,7 @@ InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub,
		mQueuedListener = new QueuedInputListener(listener);

		{ // acquire lock
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		refreshConfigurationLocked(0);
		updateGlobalMetaStateLocked();
		@@ -87,8 +87,9 @@ void InputReader::loopOnce() {
		int32_t oldGeneration;
		int32_t timeoutMillis;
		bool inputDevicesChanged = false;
		std::vector<InputDeviceInfo> inputDevices;
		{ // acquire lock
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		oldGeneration = mGeneration;
		timeoutMillis = -1;
		@@ -107,8 +108,8 @@ void InputReader::loopOnce() {
		size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);

		{ // acquire lock
		AutoMutex _l(mLock);
		mReaderIsAliveCondition.broadcast();
		std::lock_guard<std::mutex> lock(mLock);
		mReaderIsAliveCondition.notify_all();

		if (count) {
		processEventsLocked(mEventBuffer, count);
		@@ -127,12 +128,13 @@ void InputReader::loopOnce() {

		if (oldGeneration != mGeneration) {
		inputDevicesChanged = true;
		inputDevices = getInputDevicesLocked();
		}
		} // release lock

		// Send out a message that the describes the changed input devices.
		if (inputDevicesChanged) {
		mPolicy->notifyInputDevicesChanged(getInputDevicesLocked());
		mPolicy->notifyInputDevicesChanged(inputDevices);
		}

		// Flush queued events out to the listener.
		@@ -216,7 +218,7 @@ void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) {
		bumpGenerationLocked();

		if (device->getClasses().test(InputDeviceClass::EXTERNAL_STYLUS)) {
		notifyExternalStylusPresenceChanged();
		notifyExternalStylusPresenceChangedLocked();
		}
		}

		@@ -256,7 +258,7 @@ void InputReader::removeDeviceLocked(nsecs_t when, int32_t eventHubId) {
		device->removeEventHubDevice(eventHubId);

		if (device->getClasses().test(InputDeviceClass::EXTERNAL_STYLUS)) {
		notifyExternalStylusPresenceChanged();
		notifyExternalStylusPresenceChangedLocked();
		}

		if (device->hasEventHubDevices()) {
		@@ -301,7 +303,7 @@ void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEven
		device->process(rawEvents, count);
		}

		InputDevice* InputReader::findInputDevice(int32_t deviceId) {
		InputDevice* InputReader::findInputDeviceLocked(int32_t deviceId) {
		auto deviceIt =
		std::find_if(mDevices.begin(), mDevices.end(), [deviceId](const auto& devicePair) {
		return devicePair.second->getId() == deviceId;
		@@ -389,7 +391,7 @@ int32_t InputReader::getLedMetaStateLocked() {
		return mLedMetaState;
		}

		void InputReader::notifyExternalStylusPresenceChanged() {
		void InputReader::notifyExternalStylusPresenceChangedLocked() {
		refreshConfigurationLocked(InputReaderConfiguration::CHANGE_EXTERNAL_STYLUS_PRESENCE);
		}

		@@ -405,6 +407,7 @@ void InputReader::getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& o
		}

		void InputReader::dispatchExternalStylusState(const StylusState& state) {
		std::lock_guard<std::mutex> lock(mLock);
		for (auto& devicePair : mDevices) {
		std::shared_ptr<InputDevice>& device = devicePair.second;
		device->updateExternalStylusState(state);
		@@ -479,7 +482,7 @@ int32_t InputReader::bumpGenerationLocked() {
		}

		std::vector<InputDeviceInfo> InputReader::getInputDevices() const {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);
		return getInputDevicesLocked();
		}

		@@ -498,19 +501,19 @@ std::vector<InputDeviceInfo> InputReader::getInputDevicesLocked() const {
		}

		int32_t InputReader::getKeyCodeState(int32_t deviceId, uint32_t sourceMask, int32_t keyCode) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		return getStateLocked(deviceId, sourceMask, keyCode, &InputDevice::getKeyCodeState);
		}

		int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		return getStateLocked(deviceId, sourceMask, scanCode, &InputDevice::getScanCodeState);
		}

		int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		return getStateLocked(deviceId, sourceMask, switchCode, &InputDevice::getSwitchState);
		}
		@@ -519,7 +522,7 @@ int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32
		GetStateFunc getStateFunc) {
		int32_t result = AKEY_STATE_UNKNOWN;
		if (deviceId >= 0) {
		InputDevice* device = findInputDevice(deviceId);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
		result = (device->*getStateFunc)(sourceMask, code);
		}
		@@ -542,7 +545,8 @@ int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32
		}

		void InputReader::toggleCapsLockState(int32_t deviceId) {
		InputDevice* device = findInputDevice(deviceId);
		std::lock_guard<std::mutex> lock(mLock);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (!device) {
		ALOGW("Ignoring toggleCapsLock for unknown deviceId %" PRId32 ".", deviceId);
		return;
		@@ -557,7 +561,7 @@ void InputReader::toggleCapsLockState(int32_t deviceId) {

		bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes,
		const int32_t* keyCodes, uint8_t* outFlags) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		memset(outFlags, 0, numCodes);
		return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);
		@@ -568,7 +572,7 @@ bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceM
		uint8_t* outFlags) {
		bool result = false;
		if (deviceId >= 0) {
		InputDevice* device = findInputDevice(deviceId);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
		result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);
		}
		@@ -584,7 +588,7 @@ bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceM
		}

		void InputReader::requestRefreshConfiguration(uint32_t changes) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		if (changes) {
		bool needWake = !mConfigurationChangesToRefresh;
		@@ -598,26 +602,26 @@ void InputReader::requestRefreshConfiguration(uint32_t changes) {

		void InputReader::vibrate(int32_t deviceId, const std::vector<VibrationElement>& pattern,
		ssize_t repeat, int32_t token) {
		AutoMutex _l(mLock);
		InputDevice* device = findInputDevice(deviceId);
		std::lock_guard<std::mutex> lock(mLock);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (device) {
		device->vibrate(pattern, repeat, token);
		}
		}

		void InputReader::cancelVibrate(int32_t deviceId, int32_t token) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		InputDevice* device = findInputDevice(deviceId);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (device) {
		device->cancelVibrate(token);
		}
		}

		bool InputReader::isInputDeviceEnabled(int32_t deviceId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		InputDevice* device = findInputDevice(deviceId);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (device) {
		return device->isEnabled();
		}
		@@ -626,9 +630,9 @@ bool InputReader::isInputDeviceEnabled(int32_t deviceId) {
		}

		bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		InputDevice* device = findInputDevice(deviceId);
		InputDevice* device = findInputDeviceLocked(deviceId);
		if (!device) {
		ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);
		return false;
		@@ -654,7 +658,7 @@ bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {
		}

		void InputReader::dump(std::string& dump) {
		AutoMutex _l(mLock);
		std::lock_guard<std::mutex> lock(mLock);

		mEventHub->dump(dump);
		dump += "\n";
		@@ -729,11 +733,9 @@ void InputReader::dump(std::string& dump) {

		void InputReader::monitor() {
		// Acquire and release the lock to ensure that the reader has not deadlocked.
		mLock.lock();
		std::unique_lock<std::mutex> lock(mLock);
		mEventHub->wake();
		mReaderIsAliveCondition.wait(mLock);
		mLock.unlock();

		mReaderIsAliveCondition.wait(lock);
		// Check the EventHub
		mEventHub->monitor();
		}

services/inputflinger/reader/include/EventHub.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -502,7 +502,7 @@ private:
		void releaseControllerNumberLocked(int32_t num);

		// Protect all internal state.
		mutable Mutex mLock;
		mutable std::mutex mLock;

		// The actual id of the built-in keyboard, or NO_BUILT_IN_KEYBOARD if none.
		// EventHub remaps the built-in keyboard to id 0 externally as required by the API.

services/inputflinger/reader/include/InputReader.h

+67 −58

File changed.

Preview size limit exceeded, changes collapsed.

services/inputflinger/tests/InputReader_test.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -1030,8 +1030,9 @@ public:
		using InputReader::loopOnce;

		protected:
		virtual std::shared_ptr<InputDevice> createDeviceLocked(
		int32_t eventHubId, const InputDeviceIdentifier& identifier) {
		virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t eventHubId,
		const InputDeviceIdentifier& identifier)
		REQUIRES(mLock) {
		if (!mNextDevices.empty()) {
		std::shared_ptr<InputDevice> device(std::move(mNextDevices.front()));
		mNextDevices.pop();