Merge "Return events from EventHub" (df1bc056) · Commits · e / os / platform_frameworks_native

services/inputflinger/reader/EventHub.cpp

+37 −31

Original line number	Diff line number	Diff line
		@@ -76,6 +76,8 @@ static constexpr size_t OBFUSCATED_LENGTH = 8;
		static constexpr int32_t FF_STRONG_MAGNITUDE_CHANNEL_IDX = 0;
		static constexpr int32_t FF_WEAK_MAGNITUDE_CHANNEL_IDX = 1;

		static constexpr size_t EVENT_BUFFER_SIZE = 256;

		// Mapping for input battery class node IDs lookup.
		// https://www.kernel.org/doc/Documentation/power/power_supply_class.txt
		static const std::unordered_map<std::string, InputBatteryClass> BATTERY_CLASSES =
		@@ -1633,14 +1635,13 @@ std::optional<int32_t> EventHub::getBatteryStatus(int32_t deviceId, int32_t batt
		return std::nullopt;
		}

		size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
		ALOG_ASSERT(bufferSize >= 1);

		std::vector<RawEvent> EventHub::getEvents(int timeoutMillis) {
		std::scoped_lock _l(mLock);

		constexpr size_t bufferSize = EVENT_BUFFER_SIZE;
		struct input_event readBuffer[bufferSize];

		RawEvent* event = buffer;
		std::vector<RawEvent> events;
		size_t capacity = bufferSize;
		bool awoken = false;
		for (;;) {
		@@ -1661,15 +1662,17 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		for (auto it = mClosingDevices.begin(); it != mClosingDevices.end();) {
		std::unique_ptr<Device> device = std::move(*it);
		ALOGV("Reporting device closed: id=%d, name=%s\n", device->id, device->path.c_str());
		event->when = now;
		event->deviceId = (device->id == mBuiltInKeyboardId)
		const int32_t deviceId = (device->id == mBuiltInKeyboardId)
		? ReservedInputDeviceId::BUILT_IN_KEYBOARD_ID
		: device->id;
		event->type = DEVICE_REMOVED;
		event += 1;
		events.push_back({
		.when = now,
		.deviceId = deviceId,
		.type = DEVICE_REMOVED,
		});
		it = mClosingDevices.erase(it);
		mNeedToSendFinishedDeviceScan = true;
		if (--capacity == 0) {
		if (events.size() == capacity) {
		break;
		}
		}
		@@ -1684,10 +1687,12 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		std::unique_ptr<Device> device = std::move(*mOpeningDevices.rbegin());
		mOpeningDevices.pop_back();
		ALOGV("Reporting device opened: id=%d, name=%s\n", device->id, device->path.c_str());
		event->when = now;
		event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
		event->type = DEVICE_ADDED;
		event += 1;
		const int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
		events.push_back({
		.when = now,
		.deviceId = deviceId,
		.type = DEVICE_ADDED,
		});

		// Try to find a matching video device by comparing device names
		for (auto it = mUnattachedVideoDevices.begin(); it != mUnattachedVideoDevices.end();
		@@ -1705,17 +1710,18 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		ALOGW("Device id %d exists, replaced.", device->id);
		}
		mNeedToSendFinishedDeviceScan = true;
		if (--capacity == 0) {
		if (events.size() == capacity) {
		break;
		}
		}

		if (mNeedToSendFinishedDeviceScan) {
		mNeedToSendFinishedDeviceScan = false;
		event->when = now;
		event->type = FINISHED_DEVICE_SCAN;
		event += 1;
		if (--capacity == 0) {
		events.push_back({
		.when = now,
		.type = FINISHED_DEVICE_SCAN,
		});
		if (events.size() == capacity) {
		break;
		}
		}
		@@ -1794,21 +1800,21 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		} else if ((readSize % sizeof(struct input_event)) != 0) {
		ALOGE("could not get event (wrong size: %d)", readSize);
		} else {
		int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
		const int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;

		size_t count = size_t(readSize) / sizeof(struct input_event);
		const size_t count = size_t(readSize) / sizeof(struct input_event);
		for (size_t i = 0; i < count; i++) {
		struct input_event& iev = readBuffer[i];
		event->when = processEventTimestamp(iev);
		event->readTime = systemTime(SYSTEM_TIME_MONOTONIC);
		event->deviceId = deviceId;
		event->type = iev.type;
		event->code = iev.code;
		event->value = iev.value;
		event += 1;
		capacity -= 1;
		}
		if (capacity == 0) {
		events.push_back({
		.when = processEventTimestamp(iev),
		.readTime = systemTime(SYSTEM_TIME_MONOTONIC),
		.deviceId = deviceId,
		.type = iev.type,
		.code = iev.code,
		.value = iev.value,
		});
		}
		if (events.size() >= capacity) {
		// The result buffer is full. Reset the pending event index
		// so we will try to read the device again on the next iteration.
		mPendingEventIndex -= 1;
		@@ -1844,7 +1850,7 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz
		}

		// Return now if we have collected any events or if we were explicitly awoken.
		if (event != buffer \|\| awoken) {
		if (!events.empty() \|\| awoken) {
		break;
		}

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

		// All done, return the number of events we read.
		return event - buffer;
		return events;
		}

		std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {

services/inputflinger/reader/InputReader.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -120,14 +120,14 @@ void InputReader::loopOnce() {
		}
		} // release lock

		size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
		std::vector<RawEvent> events = mEventHub->getEvents(timeoutMillis);

		{ // acquire lock
		std::scoped_lock _l(mLock);
		mReaderIsAliveCondition.notify_all();

		if (count) {
		processEventsLocked(mEventBuffer, count);
		if (!events.empty()) {
		processEventsLocked(events.data(), events.size());
		}

		if (mNextTimeout != LLONG_MAX) {

services/inputflinger/reader/include/EventHub.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -282,7 +282,7 @@ public:
		*
		* Returns the number of events obtained, or 0 if the timeout expired.
		*/
		virtual size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) = 0;
		virtual std::vector<RawEvent> getEvents(int timeoutMillis) = 0;
		virtual std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) = 0;
		virtual base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(
		int32_t deviceId, int32_t absCode) const = 0;
		@@ -500,7 +500,7 @@ public:
		bool markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,
		uint8_t* outFlags) const override final;

		size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) override final;
		std::vector<RawEvent> getEvents(int timeoutMillis) override final;
		std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) override final;

		bool hasScanCode(int32_t deviceId, int32_t scanCode) const override final;

services/inputflinger/reader/include/InputReader.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -170,10 +170,6 @@ private:

		InputReaderConfiguration mConfig GUARDED_BY(mLock);

		// The event queue.
		static const int EVENT_BUFFER_SIZE = 256;
		RawEvent mEventBuffer[EVENT_BUFFER_SIZE] GUARDED_BY(mLock);

		// 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

services/inputflinger/tests/EventHub_test.cpp

+4 −6

Original line number	Diff line number	Diff line
		@@ -99,8 +99,6 @@ protected:
		};

		std::vector<RawEvent> EventHubTest::getEvents(std::optional<size_t> expectedEvents) {
		static constexpr size_t EVENT_BUFFER_SIZE = 256;
		std::array<RawEvent, EVENT_BUFFER_SIZE> eventBuffer;
		std::vector<RawEvent> events;

		while (true) {
		@@ -108,12 +106,12 @@ std::vector<RawEvent> EventHubTest::getEvents(std::optional<size_t> expectedEven
		if (expectedEvents) {
		timeout = 2s;
		}
		const size_t count =
		mEventHub->getEvents(timeout.count(), eventBuffer.data(), eventBuffer.size());
		if (count == 0) {

		std::vector<RawEvent> newEvents = mEventHub->getEvents(timeout.count());
		if (newEvents.empty()) {
		break;
		}
		events.insert(events.end(), eventBuffer.begin(), eventBuffer.begin() + count);
		events.insert(events.end(), newEvents.begin(), newEvents.end());
		if (expectedEvents && events.size() >= *expectedEvents) {
		break;
		}