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

Commit cd7d27d4 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Avoid using KeyedVector in KeyLayoutMap" into tm-dev-plus-aosp am: b5bba631 am: 273215cf 

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



Change-Id: Ia13a7741f3d31e8beb589730b020014861be3ee1
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents f7ff793c 273215cf

include/input/KeyLayoutMap.h

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

#include <stdint.h>

#include <utils/Errors.h>

#include <utils/KeyedVector.h>

#include <utils/Tokenizer.h>



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


    status_t mapKey(int32_t scanCode, int32_t usageCode,

            int32_t* outKeyCode, uint32_t* outFlags) const;

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

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

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

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

    std::optional<int32_t> findScanCodeForLed(int32_t ledCode) 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;

    // 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);
@@ -98,11 +97,11 @@ private: 
        int32_t sensorDataIndex;

    };



    KeyedVector<int32_t, Key> mKeysByScanCode;

    KeyedVector<int32_t, Key> mKeysByUsageCode;

    KeyedVector<int32_t, AxisInfo> mAxes;

    KeyedVector<int32_t, Led> mLedsByScanCode;

    KeyedVector<int32_t, Led> mLedsByUsageCode;

    std::unordered_map<int32_t, Key> mKeysByScanCode;

    std::unordered_map<int32_t, Key> mKeysByUsageCode;

    std::unordered_map<int32_t, AxisInfo> mAxes;

    std::unordered_map<int32_t, Led> mLedsByScanCode;

    std::unordered_map<int32_t, Led> mLedsByUsageCode;

    std::unordered_map<int32_t, Sensor> mSensorsByAbsCode;

    std::string mLoadFileName;

libs/input/KeyLayoutMap.cpp

+43 −52
Original line number 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 {

    if (usageCode) {

        ssize_t index = mKeysByUsageCode.indexOfKey(usageCode);

        if (index >= 0) {

            return &mKeysByUsageCode.valueAt(index);

        auto it = mKeysByUsageCode.find(usageCode);

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

            return &it->second;

        }

    }

    if (scanCode) {

        ssize_t index = mKeysByScanCode.indexOfKey(scanCode);

        if (index >= 0) {

            return &mKeysByScanCode.valueAt(index);

        auto it = mKeysByScanCode.find(scanCode);

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

            return &it->second;

        }

    }

    return nullptr;

}



status_t KeyLayoutMap::findScanCodesForKey(

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

    const size_t N = mKeysByScanCode.size();

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

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

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

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

    std::vector<int32_t> scanCodes;

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

        if (keyCode == key.keyCode) {

            scanCodes.push_back(scanCode);

        }

    }

    return NO_ERROR;

    return scanCodes;

}



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

    ssize_t index = mAxes.indexOfKey(scanCode);

    if (index < 0) {

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

    auto it = mAxes.find(scanCode);

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

        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,

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

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

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

             outAxisInfo->splitValue, outAxisInfo->flatOverride);



    return NO_ERROR;

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

             axisInfo.flatOverride);

    return axisInfo;

}



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

    const size_t N = mLedsByScanCode.size();

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

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

            *outScanCode = mLedsByScanCode.keyAt(i);

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

                     *outScanCode);

            return NO_ERROR;

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

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

        if (led.ledCode == ledCode) {

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

            return scanCode;

        }

    }

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

    return NAME_NOT_FOUND;

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

    return std::nullopt;

}



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

    const size_t N = mLedsByUsageCode.size();

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

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

            *outUsageCode = mLedsByUsageCode.keyAt(i);

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

            return NO_ERROR;

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

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

        if (led.ledCode == ledCode) {

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

            return usageCode;

        }

    }

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



    return NAME_NOT_FOUND;

    return std::nullopt;

}





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



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

        return BAD_VALUE;

    }

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

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

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

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

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

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

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

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

    key.keyCode = keyCode;

    key.flags = flags;

    map.add(code, key);

    map.insert({code, key});

    return NO_ERROR;

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

        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(),

                scanCodeToken.string());

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

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

             axisInfo.flatOverride);



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

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

    return NO_ERROR;

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

    }



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

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

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

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

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

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

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

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


    Led led;

    led.ledCode = ledCode;

    map.add(code, led);

    map.insert({code, led});

    return NO_ERROR;

}

services/inputflinger/reader/EventHub.cpp

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

    }



    std::vector<int32_t> scanCodes;

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

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

    const size_t N = scanCodes.size();

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

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

    }



    int32_t scanCode;

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

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

            *outScanCode = scanCode;

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

    if (scanCode.has_value()) {

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

            *outScanCode = *scanCode;

            return NO_ERROR;

        }

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


    Device* device = getDeviceLocked(deviceId);

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

        std::vector<int32_t> scanCodes;

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

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

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

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

                for (size_t i = 0; i < scanCodes.size(); i++) {
@@ -890,8 +888,8 @@ int32_t EventHub::getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKey 
        device->keyMap.keyLayoutMap == nullptr) {

        return AKEYCODE_UNKNOWN;

    }

    std::vector<int32_t> scanCodes;

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

    std::vector<int32_t> scanCodes =

            device->keyMap.keyLayoutMap->findScanCodesForKey(locationKeyCode);

    if (scanCodes.empty()) {

        ALOGW("Failed to get key code for key location: no scan code maps to key code %d for input"

              "device %d",
@@ -960,13 +958,10 @@ bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const in 


    Device* device = getDeviceLocked(deviceId);

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

        std::vector<int32_t> scanCodes;

        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

            // map of codes actually emitted by the driver

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

            }

        }

        }

        return true;

    }

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

    Device* device = getDeviceLocked(deviceId);



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

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

        if (err == NO_ERROR) {

            return NO_ERROR;

        }

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

        return NAME_NOT_FOUND;

    }



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

    if (!info.has_value()) {

        return NAME_NOT_FOUND;

    }

    *outAxisInfo = *info;

    return NO_ERROR;

}



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

                                                                            int32_t absCode) {