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

Commit 984f40b9 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Avoid using KeyedVector in KeyLayoutMap 

There's a supported alternative, std::unordered_map, that we should be
using instead.

Bug: 228005926
Test: atest libinput_tests inputflinger_tests
Merged-In: Ia1f41d17d7ee912534edffe1a1e7655866fa54c6
Change-Id: Ia1f41d17d7ee912534edffe1a1e7655866fa54c6
(cherry picked from commit 577962e532f235c67ea037f0fd7754834b1ff662)
parent 0a448ac7

include/input/KeyLayoutMap.h

+9 −10
Original line number Original line Diff line number Diff line
@@ -20,7 +20,6 @@ 
#include <android-base/result.h>

#include <android-base/result.h>

#include <stdint.h>

#include <stdint.h>

#include <utils/Errors.h>

#include <utils/Errors.h>

#include <utils/KeyedVector.h>

#include <utils/Tokenizer.h>

#include <utils/Tokenizer.h>





#include <input/InputDevice.h>

#include <input/InputDevice.h>
@@ -70,11 +69,11 @@ public: 




    status_t mapKey(int32_t scanCode, int32_t usageCode,

    status_t mapKey(int32_t scanCode, int32_t usageCode,

            int32_t* outKeyCode, uint32_t* outFlags) const;

            int32_t* outKeyCode, uint32_t* outFlags) const;

    status_t findScanCodesForKey(int32_t keyCode, std::vector<int32_t>* outScanCodes) const;

    std::vector<int32_t> findScanCodesForKey(int32_t keyCode) const;

    status_t findScanCodeForLed(int32_t ledCode, int32_t* outScanCode) const;

    std::optional<int32_t> findScanCodeForLed(int32_t ledCode) const;

    status_t findUsageCodeForLed(int32_t ledCode, int32_t* outUsageCode) const;

    std::optional<int32_t> findUsageCodeForLed(int32_t ledCode) const;





    status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const;

    std::optional<AxisInfo> mapAxis(int32_t scanCode) const;

    const std::string getLoadFileName() const;

    const std::string getLoadFileName() const;

    // Return pair of sensor type and sensor data index, for the input device abs code

    // Return pair of sensor type and sensor data index, for the input device abs code

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode);

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode);
@@ -98,11 +97,11 @@ private: 
        int32_t sensorDataIndex;

        int32_t sensorDataIndex;

    };

    };





    KeyedVector<int32_t, Key> mKeysByScanCode;

    std::unordered_map<int32_t, Key> mKeysByScanCode;

    KeyedVector<int32_t, Key> mKeysByUsageCode;

    std::unordered_map<int32_t, Key> mKeysByUsageCode;

    KeyedVector<int32_t, AxisInfo> mAxes;

    std::unordered_map<int32_t, AxisInfo> mAxes;

    KeyedVector<int32_t, Led> mLedsByScanCode;

    std::unordered_map<int32_t, Led> mLedsByScanCode;

    KeyedVector<int32_t, Led> mLedsByUsageCode;

    std::unordered_map<int32_t, Led> mLedsByUsageCode;

    std::unordered_map<int32_t, Sensor> mSensorsByAbsCode;

    std::unordered_map<int32_t, Sensor> mSensorsByAbsCode;

    std::string mLoadFileName;

    std::string mLoadFileName;

libs/input/KeyLayoutMap.cpp

+43 −52
Original line number Original line Diff line number Diff line
@@ -172,78 +172,68 @@ base::Result<std::pair<InputDeviceSensorType, int32_t>> KeyLayoutMap::mapSensor( 




const KeyLayoutMap::Key* KeyLayoutMap::getKey(int32_t scanCode, int32_t usageCode) const {

const KeyLayoutMap::Key* KeyLayoutMap::getKey(int32_t scanCode, int32_t usageCode) const {

    if (usageCode) {

    if (usageCode) {

        ssize_t index = mKeysByUsageCode.indexOfKey(usageCode);

        auto it = mKeysByUsageCode.find(usageCode);

        if (index >= 0) {

        if (it != mKeysByUsageCode.end()) {

            return &mKeysByUsageCode.valueAt(index);

            return &it->second;

        }

        }

    }

    }

    if (scanCode) {

    if (scanCode) {

        ssize_t index = mKeysByScanCode.indexOfKey(scanCode);

        auto it = mKeysByScanCode.find(scanCode);

        if (index >= 0) {

        if (it != mKeysByScanCode.end()) {

            return &mKeysByScanCode.valueAt(index);

            return &it->second;

        }

        }

    }

    }

    return nullptr;

    return nullptr;

}

}





status_t KeyLayoutMap::findScanCodesForKey(

std::vector<int32_t> KeyLayoutMap::findScanCodesForKey(int32_t keyCode) const {

        int32_t keyCode, std::vector<int32_t>* outScanCodes) const {

    std::vector<int32_t> scanCodes;

    const size_t N = mKeysByScanCode.size();

    for (const auto& [scanCode, key] : mKeysByScanCode) {

    for (size_t i=0; i<N; i++) {

        if (keyCode == key.keyCode) {

        if (mKeysByScanCode.valueAt(i).keyCode == keyCode) {

            scanCodes.push_back(scanCode);

            outScanCodes->push_back(mKeysByScanCode.keyAt(i));

        }

        }

    }

    }

    return NO_ERROR;

    return scanCodes;

}

}





status_t KeyLayoutMap::mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const {

std::optional<AxisInfo> KeyLayoutMap::mapAxis(int32_t scanCode) const {

    ssize_t index = mAxes.indexOfKey(scanCode);

    auto it = mAxes.find(scanCode);

    if (index < 0) {

    if (it == mAxes.end()) {

        ALOGD_IF(DEBUG_MAPPING, "mapAxis: scanCode=%d ~ Failed.", scanCode);

        ALOGD_IF(DEBUG_MAPPING, "mapAxis: scanCode=%d ~ Failed.", scanCode);

        return NAME_NOT_FOUND;

        return std::nullopt;

    }

    }





    *outAxisInfo = mAxes.valueAt(index);

    const AxisInfo& axisInfo = it->second;



    ALOGD_IF(DEBUG_MAPPING,

    ALOGD_IF(DEBUG_MAPPING,

             "mapAxis: scanCode=%d ~ Result mode=%d, axis=%d, highAxis=%d, "

             "mapAxis: scanCode=%d ~ Result mode=%d, axis=%d, highAxis=%d, "

             "splitValue=%d, flatOverride=%d.",

             "splitValue=%d, flatOverride=%d.",

             scanCode, outAxisInfo->mode, outAxisInfo->axis, outAxisInfo->highAxis,

             scanCode, axisInfo.mode, axisInfo.axis, axisInfo.highAxis, axisInfo.splitValue,

             outAxisInfo->splitValue, outAxisInfo->flatOverride);

             axisInfo.flatOverride);



    return axisInfo;

    return NO_ERROR;

}

}





status_t KeyLayoutMap::findScanCodeForLed(int32_t ledCode, int32_t* outScanCode) const {

std::optional<int32_t> KeyLayoutMap::findScanCodeForLed(int32_t ledCode) const {

    const size_t N = mLedsByScanCode.size();

    for (const auto& [scanCode, led] : mLedsByScanCode) {

    for (size_t i = 0; i < N; i++) {

        if (led.ledCode == ledCode) {

        if (mLedsByScanCode.valueAt(i).ledCode == ledCode) {

            ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d, scanCode=%d.", __func__, ledCode, scanCode);

            *outScanCode = mLedsByScanCode.keyAt(i);

            return scanCode;

            ALOGD_IF(DEBUG_MAPPING, "findScanCodeForLed: ledCode=%d, scanCode=%d.", ledCode,

                     *outScanCode);

            return NO_ERROR;

        }

        }

    }

    }

    ALOGD_IF(DEBUG_MAPPING, "findScanCodeForLed: ledCode=%d ~ Not found.", ledCode);

    ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d ~ Not found.", __func__, ledCode);

    return NAME_NOT_FOUND;

    return std::nullopt;

}

}





status_t KeyLayoutMap::findUsageCodeForLed(int32_t ledCode, int32_t* outUsageCode) const {

std::optional<int32_t> KeyLayoutMap::findUsageCodeForLed(int32_t ledCode) const {

    const size_t N = mLedsByUsageCode.size();

    for (const auto& [usageCode, led] : mLedsByUsageCode) {

    for (size_t i = 0; i < N; i++) {

        if (led.ledCode == ledCode) {

        if (mLedsByUsageCode.valueAt(i).ledCode == ledCode) {

            ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d, usage=%x.", __func__, ledCode, usageCode);

            *outUsageCode = mLedsByUsageCode.keyAt(i);

            return usageCode;

            ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d, usage=%x.", __func__, ledCode, *outUsageCode);

            return NO_ERROR;

        }

        }

    }

    }

    ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d ~ Not found.", __func__, ledCode);

    ALOGD_IF(DEBUG_MAPPING, "%s: ledCode=%d ~ Not found.", __func__, ledCode);



    return std::nullopt;

    return NAME_NOT_FOUND;

}

}







// --- KeyLayoutMap::Parser ---

// --- KeyLayoutMap::Parser ---





KeyLayoutMap::Parser::Parser(KeyLayoutMap* map, Tokenizer* tokenizer) :

KeyLayoutMap::Parser::Parser(KeyLayoutMap* map, Tokenizer* tokenizer) :
@@ -314,8 +304,9 @@ status_t KeyLayoutMap::Parser::parseKey() { 
                mapUsage ? "usage" : "scan code", codeToken.string());

                mapUsage ? "usage" : "scan code", codeToken.string());

        return BAD_VALUE;

        return BAD_VALUE;

    }

    }

    KeyedVector<int32_t, Key>& map = mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;

    std::unordered_map<int32_t, Key>& map =

    if (map.indexOfKey(code) >= 0) {

            mapUsage ? mMap->mKeysByUsageCode : mMap->mKeysByScanCode;

    if (map.find(code) != map.end()) {

        ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),

        ALOGE("%s: Duplicate entry for key %s '%s'.", mTokenizer->getLocation().string(),

                mapUsage ? "usage" : "scan code", codeToken.string());

                mapUsage ? "usage" : "scan code", codeToken.string());

        return BAD_VALUE;

        return BAD_VALUE;
@@ -356,7 +347,7 @@ status_t KeyLayoutMap::Parser::parseKey() { 
    Key key;

    Key key;

    key.keyCode = keyCode;

    key.keyCode = keyCode;

    key.flags = flags;

    key.flags = flags;

    map.add(code, key);

    map.insert({code, key});

    return NO_ERROR;

    return NO_ERROR;

}

}
@@ -369,7 +360,7 @@ status_t KeyLayoutMap::Parser::parseAxis() { 
                scanCodeToken.string());

                scanCodeToken.string());

        return BAD_VALUE;

        return BAD_VALUE;

    }

    }

    if (mMap->mAxes.indexOfKey(scanCode) >= 0) {

    if (mMap->mAxes.find(scanCode) != mMap->mAxes.end()) {

        ALOGE("%s: Duplicate entry for axis scan code '%s'.", mTokenizer->getLocation().string(),

        ALOGE("%s: Duplicate entry for axis scan code '%s'.", mTokenizer->getLocation().string(),

                scanCodeToken.string());

                scanCodeToken.string());

        return BAD_VALUE;

        return BAD_VALUE;
@@ -455,8 +446,7 @@ status_t KeyLayoutMap::Parser::parseAxis() { 
             "splitValue=%d, flatOverride=%d.",

             "splitValue=%d, flatOverride=%d.",

             scanCode, axisInfo.mode, axisInfo.axis, axisInfo.highAxis, axisInfo.splitValue,

             scanCode, axisInfo.mode, axisInfo.axis, axisInfo.highAxis, axisInfo.splitValue,

             axisInfo.flatOverride);

             axisInfo.flatOverride);



    mMap->mAxes.insert({scanCode, axisInfo});

    mMap->mAxes.add(scanCode, axisInfo);

    return NO_ERROR;

    return NO_ERROR;

}

}
@@ -476,8 +466,9 @@ status_t KeyLayoutMap::Parser::parseLed() { 
        return BAD_VALUE;

        return BAD_VALUE;

    }

    }





    KeyedVector<int32_t, Led>& map = mapUsage ? mMap->mLedsByUsageCode : mMap->mLedsByScanCode;

    std::unordered_map<int32_t, Led>& map =

    if (map.indexOfKey(code) >= 0) {

            mapUsage ? mMap->mLedsByUsageCode : mMap->mLedsByScanCode;

    if (map.find(code) != map.end()) {

        ALOGE("%s: Duplicate entry for led %s '%s'.", mTokenizer->getLocation().string(),

        ALOGE("%s: Duplicate entry for led %s '%s'.", mTokenizer->getLocation().string(),

                mapUsage ? "usage" : "scan code", codeToken.string());

                mapUsage ? "usage" : "scan code", codeToken.string());

        return BAD_VALUE;

        return BAD_VALUE;
@@ -497,7 +488,7 @@ status_t KeyLayoutMap::Parser::parseLed() { 




    Led led;

    Led led;

    led.ledCode = ledCode;

    led.ledCode = ledCode;

    map.add(code, led);

    map.insert({code, led});

    return NO_ERROR;

    return NO_ERROR;

}

}

services/inputflinger/reader/EventHub.cpp

+23 −28
Original line number Original line Diff line number Diff line
@@ -449,8 +449,7 @@ bool EventHub::Device::hasKeycodeLocked(int keycode) const { 
        return false;

        return false;

    }

    }





    std::vector<int32_t> scanCodes;

    std::vector<int32_t> scanCodes = keyMap.keyLayoutMap->findScanCodesForKey(keycode);

    keyMap.keyLayoutMap->findScanCodesForKey(keycode, &scanCodes);

    const size_t N = scanCodes.size();

    const size_t N = scanCodes.size();

    for (size_t i = 0; i < N && i <= KEY_MAX; i++) {

    for (size_t i = 0; i < N && i <= KEY_MAX; i++) {

        int32_t sc = scanCodes[i];

        int32_t sc = scanCodes[i];
@@ -545,10 +544,10 @@ status_t EventHub::Device::mapLed(int32_t led, int32_t* outScanCode) const { 
        return NAME_NOT_FOUND;

        return NAME_NOT_FOUND;

    }

    }





    int32_t scanCode;

    std::optional<int32_t> scanCode = keyMap.keyLayoutMap->findScanCodeForLed(led);

    if (keyMap.keyLayoutMap->findScanCodeForLed(led, &scanCode) != NAME_NOT_FOUND) {

    if (scanCode.has_value()) {

        if (scanCode >= 0 && scanCode <= LED_MAX && ledBitmask.test(scanCode)) {

        if (*scanCode >= 0 && *scanCode <= LED_MAX && ledBitmask.test(*scanCode)) {

            *outScanCode = scanCode;

            *outScanCode = *scanCode;

            return NO_ERROR;

            return NO_ERROR;

        }

        }

    }

    }
@@ -862,8 +861,7 @@ int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const { 




    Device* device = getDeviceLocked(deviceId);

    Device* device = getDeviceLocked(deviceId);

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

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

        std::vector<int32_t> scanCodes;

        std::vector<int32_t> scanCodes = device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode);

        device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes);

        if (scanCodes.size() != 0) {

        if (scanCodes.size() != 0) {

            if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {

            if (device->readDeviceBitMask(EVIOCGKEY(0), device->keyState) >= 0) {

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

                for (size_t i = 0; i < scanCodes.size(); i++) {
@@ -921,13 +919,10 @@ bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const in 




    Device* device = getDeviceLocked(deviceId);

    Device* device = getDeviceLocked(deviceId);

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

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

        std::vector<int32_t> scanCodes;

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

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

            scanCodes.clear();

            std::vector<int32_t> scanCodes =

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





            status_t err = device->keyMap.keyLayoutMap->findScanCodesForKey(keyCodes[codeIndex],

                                                                            &scanCodes);

            if (!err) {

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

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

            // map of codes actually emitted by the driver

            // map of codes actually emitted by the driver

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

            for (size_t sc = 0; sc < scanCodes.size(); sc++) {
@@ -937,7 +932,6 @@ bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const in 
                }

                }

            }

            }

        }

        }

        }

        return true;

        return true;

    }

    }

    return false;

    return false;
@@ -988,15 +982,16 @@ status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxis 
    std::scoped_lock _l(mLock);

    std::scoped_lock _l(mLock);

    Device* device = getDeviceLocked(deviceId);

    Device* device = getDeviceLocked(deviceId);





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

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

        status_t err = device->keyMap.keyLayoutMap->mapAxis(scanCode, outAxisInfo);

        return NAME_NOT_FOUND;

        if (err == NO_ERROR) {

            return NO_ERROR;

        }

    }

    }



    std::optional<AxisInfo> info = device->keyMap.keyLayoutMap->mapAxis(scanCode);

    if (!info.has_value()) {

        return NAME_NOT_FOUND;

        return NAME_NOT_FOUND;

    }

    }

    *outAxisInfo = *info;

    return NO_ERROR;

}





base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId,

base::Result<std::pair<InputDeviceSensorType, int32_t>> EventHub::mapSensor(int32_t deviceId,

                                                                            int32_t absCode) {

                                                                            int32_t absCode) {