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

Commit 691001a8 authored by Arpit Singh's avatar Arpit Singh Committed by Automerger Merge Worker
Browse files

InputMapper refactor: Configure empty InputDevice am: 4f61f3c9 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/23660747



Change-Id: I117c0267ba94c4b07a967e0ef28ad0513f244be3
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents eae9bd0a 4f61f3c9

services/inputflinger/reader/InputDevice.cpp

+16 −19
Original line number Diff line number Diff line
@@ -171,18 +171,23 @@ void InputDevice::addEmptyEventHubDevice(int32_t eventHubId) { 
    mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});

}



void InputDevice::addEventHubDevice(int32_t eventHubId,

                                    const InputReaderConfiguration& readerConfig) {

[[nodiscard]] std::list<NotifyArgs> InputDevice::addEventHubDevice(

        nsecs_t when, int32_t eventHubId, const InputReaderConfiguration& readerConfig) {

    if (mDevices.find(eventHubId) != mDevices.end()) {

        return;

        return {};

    }

    std::unique_ptr<InputDeviceContext> contextPtr(new InputDeviceContext(*this, eventHubId));

    std::vector<std::unique_ptr<InputMapper>> mappers = createMappers(*contextPtr, readerConfig);



    // insert the context into the devices set

    mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});

    // Add an empty device configure and keep it enabled to allow mapper population

    // with correct configuration/context

    addEmptyEventHubDevice(eventHubId);

    std::list<NotifyArgs> out = configure(when, readerConfig, {}, /*forceEnable=*/true);



    DevicePair& devicePair = mDevices[eventHubId];

    devicePair.second = createMappers(*devicePair.first, readerConfig);



    // Must change generation to flag this device as changed

    bumpGeneration();

    return out;

}



void InputDevice::removeEventHubDevice(int32_t eventHubId) {
@@ -195,7 +200,7 @@ void InputDevice::removeEventHubDevice(int32_t eventHubId) { 


std::list<NotifyArgs> InputDevice::configure(nsecs_t when,

                                             const InputReaderConfiguration& readerConfig,

                                             ConfigurationChanges changes) {

                                             ConfigurationChanges changes, bool forceEnable) {

    std::list<NotifyArgs> out;

    mSources = 0;

    mClasses = ftl::Flags<InputDeviceClass>(0);
@@ -308,25 +313,17 @@ std::list<NotifyArgs> InputDevice::configure(nsecs_t when, 
            }

        }



        if (changes.test(Change::ENABLED_STATE) || changes.test(Change::DISPLAY_INFO)) {

        if (!changes.any() || changes.test(Change::ENABLED_STATE) ||

            changes.test(Change::DISPLAY_INFO)) {

            // Whether a device is enabled can depend on the display association,

            // so update the enabled state when there is a change in display info.

            // NOTE: The first configuration of a mapper must happen with the device enabled.

            // Do not execute this code on the first configure to prevent mappers

            // from being configured with the device disabled.

            out += updateEnableState(when, readerConfig, false);

            out += updateEnableState(when, readerConfig, forceEnable);

        }



        for_each_mapper([this, when, &readerConfig, changes, &out](InputMapper& mapper) {

            out += mapper.reconfigure(when, readerConfig, changes);

            mSources |= mapper.getSources();

        });



        // If a device is just plugged but it might be disabled, we need to update some info like

        // axis range of touch from each InputMapper first, then disable it.

        if (!changes.any()) {

            out += updateEnableState(when, readerConfig);

        }

    }

    return out;

}

services/inputflinger/reader/InputReader.cpp

+3 −3
Original line number Diff line number Diff line
@@ -234,7 +234,7 @@ void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) { 
    }



    InputDeviceIdentifier identifier = mEventHub->getDeviceIdentifier(eventHubId);

    std::shared_ptr<InputDevice> device = createDeviceLocked(eventHubId, identifier);

    std::shared_ptr<InputDevice> device = createDeviceLocked(when, eventHubId, identifier);



    notifyAll(device->configure(when, mConfig, /*changes=*/{}));

    notifyAll(device->reset(when));
@@ -319,7 +319,7 @@ void InputReader::removeDeviceLocked(nsecs_t when, int32_t eventHubId) { 
}



std::shared_ptr<InputDevice> InputReader::createDeviceLocked(

        int32_t eventHubId, const InputDeviceIdentifier& identifier) {

        nsecs_t when, int32_t eventHubId, const InputDeviceIdentifier& identifier) {

    auto deviceIt = std::find_if(mDevices.begin(), mDevices.end(), [identifier](auto& devicePair) {

        const InputDeviceIdentifier identifier2 =

                devicePair.second->getDeviceInfo().getIdentifier();
@@ -334,7 +334,7 @@ std::shared_ptr<InputDevice> InputReader::createDeviceLocked( 
        device = std::make_shared<InputDevice>(&mContext, deviceId, bumpGenerationLocked(),

                                               identifier);

    }

    device->addEventHubDevice(eventHubId, mConfig);

    notifyAll(device->addEventHubDevice(when, eventHubId, mConfig));

    return device;

}

services/inputflinger/reader/include/InputDevice.h

+4 −2
Original line number Diff line number Diff line
@@ -80,11 +80,13 @@ public: 


    void dump(std::string& dump, const std::string& eventHubDevStr);

    void addEmptyEventHubDevice(int32_t eventHubId);

    void addEventHubDevice(int32_t eventHubId, const InputReaderConfiguration& readerConfig);

    [[nodiscard]] std::list<NotifyArgs> addEventHubDevice(

            nsecs_t when, int32_t eventHubId, const InputReaderConfiguration& readerConfig);

    void removeEventHubDevice(int32_t eventHubId);

    [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when,

                                                  const InputReaderConfiguration& readerConfig,

                                                  ConfigurationChanges changes);

                                                  ConfigurationChanges changes,

                                                  bool forceEnable = false);

    [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when);

    [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvents, size_t count);

    [[nodiscard]] std::list<NotifyArgs> timeoutExpired(nsecs_t when);

services/inputflinger/reader/include/InputReader.h

+1 −1
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ public: 


protected:

    // These members are protected so they can be instrumented by test cases.

    virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t deviceId,

    virtual std::shared_ptr<InputDevice> createDeviceLocked(nsecs_t when, int32_t deviceId,

                                                            const InputDeviceIdentifier& identifier)

            REQUIRES(mLock);

services/inputflinger/tests/InputReader_test.cpp

+2 −1
Original line number Diff line number Diff line
@@ -2584,7 +2584,8 @@ TEST_F(InputDeviceTest, DumpDoesNotCrash) { 
    mFakeEventHub->addDevice(TEST_EVENTHUB_ID, "Test EventHub device", InputDeviceClass::BATTERY);















    InputDevice device(mReader->getContext(), /*id=*/1, /*generation=*/2, /*identifier=*/{});













    device.addEventHubDevice(TEST_EVENTHUB_ID, mFakePolicy->getReaderConfiguration());













    auto _ = device.addEventHubDevice(ARBITRARY_TIME, TEST_EVENTHUB_ID,













                                      mFakePolicy->getReaderConfiguration());















    device.removeEventHubDevice(TEST_EVENTHUB_ID);















    std::string dumpStr, eventHubDevStr;















    device.dump(dumpStr, eventHubDevStr);