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

Commit 74007943 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Use std::vector when sending keyCodes 

We are currently sending a raw pointer to keyCodes and a size. The size
is also used for outFlags, but it's not well-documented anyways.

Eventually, we may want to just return the flags instead of returning
the boolean.

For now, though, just change the incoming parameter to a vector to make
it less errorprone.

Bug: 228005926
Test: atest libinput_tests inputflinger_tests
Change-Id: I6cc2f5d9b3b7b7c3c120a779ea4cfb4b06e27d1e
parent 456acaae

services/inputflinger/include/InputReaderBase.h

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


    /* Determine whether physical keys exist for the given framework-domain key codes. */

    virtual bool hasKeys(int32_t deviceId, uint32_t sourceMask,

            size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) = 0;

                         const std::vector<int32_t>& keyCodes, uint8_t* outFlags) = 0;



    /* Requests that a reconfiguration of all input devices.

     * The changes flag is a bitfield that indicates what has changed and whether

services/inputflinger/reader/EventHub.cpp

+4 −4
Original line number Diff line number Diff line
@@ -952,20 +952,20 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* 
    return -1;

}



bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,

bool EventHub::markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,

                                     uint8_t* outFlags) const {

    std::scoped_lock _l(mLock);



    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->keyMap.haveKeyLayout()) {

        for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) {

        for (size_t codeIndex = 0; codeIndex < keyCodes.size(); codeIndex++) {

            std::vector<int32_t> scanCodes =

                    device->keyMap.keyLayoutMap->findScanCodesForKey(keyCodes[codeIndex]);



            // check the possible scan codes identified by the layout map against the

            // map of codes actually emitted by the driver

            for (size_t sc = 0; sc < scanCodes.size(); sc++) {

                if (device->keyBitmask.test(scanCodes[sc])) {

            for (const int32_t scanCode : scanCodes) {

                if (device->keyBitmask.test(scanCode)) {

                    outFlags[codeIndex] = 1;

                    break;

                }

services/inputflinger/reader/InputDevice.cpp

+4 −4
Original line number Diff line number Diff line
@@ -465,12 +465,12 @@ int32_t InputDevice::getState(uint32_t sourceMask, int32_t code, GetStateFunc ge 
    return result;

}



bool InputDevice::markSupportedKeyCodes(uint32_t sourceMask, size_t numCodes,

                                        const int32_t* keyCodes, uint8_t* outFlags) {

bool InputDevice::markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes,

                                        uint8_t* outFlags) {

    bool result = false;

    for_each_mapper([&result, sourceMask, numCodes, keyCodes, outFlags](InputMapper& mapper) {

    for_each_mapper([&result, sourceMask, keyCodes, outFlags](InputMapper& mapper) {

        if (sourcesMatchMask(mapper.getSources(), sourceMask)) {

            result |= mapper.markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);

            result |= mapper.markSupportedKeyCodes(sourceMask, keyCodes, outFlags);

        }

    });

    return result;

services/inputflinger/reader/InputReader.cpp

+7 −7
Original line number Diff line number Diff line
@@ -561,28 +561,28 @@ void InputReader::toggleCapsLockState(int32_t deviceId) { 
    device->updateMetaState(AKEYCODE_CAPS_LOCK);

}



bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes,

                          const int32_t* keyCodes, uint8_t* outFlags) {

bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask,

                          const std::vector<int32_t>& keyCodes, uint8_t* outFlags) {

    std::scoped_lock _l(mLock);



    memset(outFlags, 0, numCodes);

    return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);

    memset(outFlags, 0, keyCodes.size());

    return markSupportedKeyCodesLocked(deviceId, sourceMask, keyCodes, outFlags);

}



bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceMask,

                                              size_t numCodes, const int32_t* keyCodes,

                                              const std::vector<int32_t>& keyCodes,

                                              uint8_t* outFlags) {

    bool result = false;

    if (deviceId >= 0) {

        InputDevice* device = findInputDeviceLocked(deviceId);

        if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {

            result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);

            result = device->markSupportedKeyCodes(sourceMask, keyCodes, outFlags);

        }

    } else {

        for (auto& devicePair : mDevices) {

            std::shared_ptr<InputDevice>& device = devicePair.second;

            if (!device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {

                result |= device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);

                result |= device->markSupportedKeyCodes(sourceMask, keyCodes, outFlags);

            }

        }

    }

services/inputflinger/reader/include/EventHub.h

+2 −2
Original line number Diff line number Diff line
@@ -311,7 +311,7 @@ public: 
    /*

     * Examine key input devices for specific framework keycode support

     */

    virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,

    virtual bool markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,

                                       uint8_t* outFlags) const = 0;



    virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const = 0;
@@ -488,7 +488,7 @@ public: 
    status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,

                                  int32_t* outValue) const override final;



    bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,

    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;