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

services/inputflinger/reader/EventHub.cpp

+31 −32

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

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

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

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

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

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

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {		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 {		bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
	if (axis >= 0 && axis <= REL_MAX) {		if (axis >= 0 && axis <= REL_MAX) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	return device != nullptr ? device->relBitmask.test(axis) : false;		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 {		bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr		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 {		int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
	if (scanCode >= 0 && scanCode <= KEY_MAX) {		if (scanCode >= 0 && scanCode <= KEY_MAX) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) {		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 {		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);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) {		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 {		int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
	if (sw >= 0 && sw <= SW_MAX) {		if (sw >= 0 && sw <= SW_MAX) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) {		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;		*outValue = 0;

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

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {		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,		bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
	uint8_t* outFlags) const {		uint8_t* outFlags) const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->keyMap.haveKeyLayout()) {		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,		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 {		int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	status_t status = NAME_NOT_FOUND;		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 {		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);		Device* device = getDeviceLocked(deviceId);

	if (device != nullptr && device->keyMap.haveKeyLayout()) {		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) {		void EventHub::setExcludedDevices(const std::vector<std::string>& devices) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

	mExcludedDevices = devices;		mExcludedDevices = devices;
	}		}

	bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {		bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {		if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {
	return device->keyBitmask.test(scanCode);		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 {		bool EventHub::hasLed(int32_t deviceId, int32_t led) const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	int32_t sc;		int32_t sc;
	if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) {		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) {		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);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->hasValidFd()) {		if (device != nullptr && device->hasValidFd()) {
	device->setLedStateLocked(led, on);		device->setLedStateLocked(led, on);
	@@ -742,7 +742,7 @@ void EventHub::getVirtualKeyDefinitions(int32_t deviceId,
	std::vector<VirtualKeyDefinition>& outVirtualKeys) const {		std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
	outVirtualKeys.clear();		outVirtualKeys.clear();

	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && device->virtualKeyMap) {		if (device != nullptr && device->virtualKeyMap) {
	const std::vector<VirtualKeyDefinition> virtualKeys =		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 {		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);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr) {		if (device != nullptr) {
	return device->getKeyCharacterMap();		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) {		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);		Device* device = getDeviceLocked(deviceId);
	if (device != nullptr && map != nullptr && device->keyMap.keyCharacterMap != nullptr) {		if (device != nullptr && map != nullptr && device->keyMap.keyCharacterMap != nullptr) {
	device->keyMap.keyCharacterMap->combine(*map);		device->keyMap.keyCharacterMap->combine(*map);
	@@ -822,7 +822,7 @@ void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) {
	}		}

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

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

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

	struct input_event readBuffer[bufferSize];		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) {		std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

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

	bool EventHub::isDeviceEnabled(int32_t deviceId) {		bool EventHub::isDeviceEnabled(int32_t deviceId) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device == nullptr) {		if (device == nullptr) {
	ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);		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) {		status_t EventHub::enableDevice(int32_t deviceId) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device == nullptr) {		if (device == nullptr) {
	ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);		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) {		status_t EventHub::disableDevice(int32_t deviceId) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device == nullptr) {		if (device == nullptr) {
	ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);		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() {		void EventHub::requestReopenDevices() {
	ALOGV("requestReopenDevices() called");		ALOGV("requestReopenDevices() called");

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

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

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

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

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

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

	}; // namespace android		}; // namespace android

services/inputflinger/reader/InputReader.cpp

+33 −31

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

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

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

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

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

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

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

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

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

	if (device->getClasses().test(InputDeviceClass::EXTERNAL_STYLUS)) {		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);		device->removeEventHubDevice(eventHubId);

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

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

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

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

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

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

	std::vector<InputDeviceInfo> InputReader::getInputDevices() const {		std::vector<InputDeviceInfo> InputReader::getInputDevices() const {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);
	return getInputDevicesLocked();		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) {		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);		return getStateLocked(deviceId, sourceMask, keyCode, &InputDevice::getKeyCodeState);
	}		}

	int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode) {		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);		return getStateLocked(deviceId, sourceMask, scanCode, &InputDevice::getScanCodeState);
	}		}

	int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) {		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);		return getStateLocked(deviceId, sourceMask, switchCode, &InputDevice::getSwitchState);
	}		}
	@@ -519,7 +522,7 @@ int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32
	GetStateFunc getStateFunc) {		GetStateFunc getStateFunc) {
	int32_t result = AKEY_STATE_UNKNOWN;		int32_t result = AKEY_STATE_UNKNOWN;
	if (deviceId >= 0) {		if (deviceId >= 0) {
	InputDevice* device = findInputDevice(deviceId);		InputDevice* device = findInputDeviceLocked(deviceId);
	if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {		if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
	result = (device->*getStateFunc)(sourceMask, code);		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) {		void InputReader::toggleCapsLockState(int32_t deviceId) {
	InputDevice* device = findInputDevice(deviceId);		std::lock_guard<std::mutex> lock(mLock);
			InputDevice* device = findInputDeviceLocked(deviceId);
	if (!device) {		if (!device) {
	ALOGW("Ignoring toggleCapsLock for unknown deviceId %" PRId32 ".", deviceId);		ALOGW("Ignoring toggleCapsLock for unknown deviceId %" PRId32 ".", deviceId);
	return;		return;
	@@ -557,7 +561,7 @@ void InputReader::toggleCapsLockState(int32_t deviceId) {

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

	memset(outFlags, 0, numCodes);		memset(outFlags, 0, numCodes);
	return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);		return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);
	@@ -568,7 +572,7 @@ bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceM
	uint8_t* outFlags) {		uint8_t* outFlags) {
	bool result = false;		bool result = false;
	if (deviceId >= 0) {		if (deviceId >= 0) {
	InputDevice* device = findInputDevice(deviceId);		InputDevice* device = findInputDeviceLocked(deviceId);
	if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {		if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {
	result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);		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) {		void InputReader::requestRefreshConfiguration(uint32_t changes) {
	AutoMutex _l(mLock);		std::lock_guard<std::mutex> lock(mLock);

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

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

	void InputReader::cancelVibrate(int32_t deviceId, int32_t 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) {		if (device) {
	device->cancelVibrate(token);		device->cancelVibrate(token);
	}		}
	}		}

	bool InputReader::isInputDeviceEnabled(int32_t deviceId) {		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) {		if (device) {
	return device->isEnabled();		return device->isEnabled();
	}		}
	@@ -626,9 +630,9 @@ bool InputReader::isInputDeviceEnabled(int32_t deviceId) {
	}		}

	bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {		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) {		if (!device) {
	ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);		ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);
	return false;		return false;
	@@ -654,7 +658,7 @@ bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {
	}		}

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

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

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

	// Check the EventHub		// Check the EventHub
	mEventHub->monitor();		mEventHub->monitor();
	}		}

services/inputflinger/reader/include/EventHub.h

+1 −1

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

	// Protect all internal state.		// 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.		// 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.		// 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	Original line	Diff line number	Diff line
	@@ -1030,8 +1030,9 @@ public:
	using InputReader::loopOnce;		using InputReader::loopOnce;

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