Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7b3ea0be authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Return events from EventHub 

Rather than filling some buffer, EventHub will now return events
explicitly. This will simplify the interface and avoid storing the
buffer when no events are being actively produced.

Bug: 211379801
Test: atest libinput_tests inputflinger_tests
Change-Id: Ic4ba7789f899b2de9fbe5a0abe54475b74eb5f82
parent 6f8b77e3

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;

        }