Merge "Avoid using KeyedVector in KeyLayoutMap" (ef6be333) · Commits · e / os / android_frameworks_native

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) {