Merge "Fix getSwitchState and others to check bitmasks. Bug: 5149443" (7034e4e6) · Commits · e / os / android_frameworks_base

services/input/EventHub.cpp

+76 −115

Original line number	Original line	Diff line number	Diff line
	@@ -205,12 +205,12 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
	RawAbsoluteAxisInfo* outAxisInfo) const {		RawAbsoluteAxisInfo* outAxisInfo) const {
	outAxisInfo->clear();		outAxisInfo->clear();

			if (axis >= 0 && axis <= ABS_MAX) {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);
	Device* device = getDeviceLocked(deviceId);
	if (device == NULL) return -1;

			Device* device = getDeviceLocked(deviceId);
			if (device && test_bit(axis, device->absBitmask)) {
	struct input_absinfo info;		struct input_absinfo info;

	if(ioctl(device->fd, EVIOCGABS(axis), &info)) {		if(ioctl(device->fd, EVIOCGABS(axis), &info)) {
	LOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",		LOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",
	axis, device->identifier.name.string(), device->fd, errno);		axis, device->identifier.name.string(), device->fd, errno);
	@@ -227,13 +227,16 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
	}		}
	return OK;		return OK;
	}		}
			}
			return -1;
			}

	bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {		bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
	if (axis >= 0 && axis <= REL_MAX) {		if (axis >= 0 && axis <= REL_MAX) {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device && device->relBitmask) {		if (device) {
	return test_bit(axis, device->relBitmask);		return test_bit(axis, device->relBitmask);
	}		}
	}		}
	@@ -245,7 +248,7 @@ bool EventHub::hasInputProperty(int32_t deviceId, int property) const {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device && device->propBitmask) {		if (device) {
	return test_bit(property, device->propBitmask);		return test_bit(property, device->propBitmask);
	}		}
	}		}
	@@ -257,19 +260,13 @@ int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != NULL) {		if (device && test_bit(scanCode, device->keyBitmask)) {
	return getScanCodeStateLocked(device, scanCode);		uint8_t keyState[sizeof_bit_array(KEY_MAX + 1)];
			memset(keyState, 0, sizeof(keyState));
			if (ioctl(device->fd, EVIOCGKEY(sizeof(keyState)), keyState) >= 0) {
			return test_bit(scanCode, keyState) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
	}		}
	}		}
	return AKEY_STATE_UNKNOWN;
	}

	int32_t EventHub::getScanCodeStateLocked(Device* device, int32_t scanCode) const {
	uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];
	memset(key_bitmask, 0, sizeof(key_bitmask));
	if (ioctl(device->fd,
	EVIOCGKEY(sizeof(key_bitmask)), key_bitmask) >= 0) {
	return test_bit(scanCode, key_bitmask) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
	}		}
	return AKEY_STATE_UNKNOWN;		return AKEY_STATE_UNKNOWN;
	}		}
	@@ -278,38 +275,23 @@ int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != NULL) {		if (device && device->keyMap.haveKeyLayout()) {
	return getKeyCodeStateLocked(device, keyCode);
	}
	return AKEY_STATE_UNKNOWN;
	}

	int32_t EventHub::getKeyCodeStateLocked(Device* device, int32_t keyCode) const {
	if (!device->keyMap.haveKeyLayout()) {
	return AKEY_STATE_UNKNOWN;
	}

	Vector<int32_t> scanCodes;		Vector<int32_t> scanCodes;
	device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes);		device->keyMap.keyLayoutMap->findScanCodesForKey(keyCode, &scanCodes);
			if (scanCodes.size() != 0) {
	uint8_t key_bitmask[sizeof_bit_array(KEY_MAX + 1)];		uint8_t keyState[sizeof_bit_array(KEY_MAX + 1)];
	memset(key_bitmask, 0, sizeof(key_bitmask));		memset(keyState, 0, sizeof(keyState));
	if (ioctl(device->fd, EVIOCGKEY(sizeof(key_bitmask)), key_bitmask) >= 0) {		if (ioctl(device->fd, EVIOCGKEY(sizeof(keyState)), keyState) >= 0) {
	#if 0		for (size_t i = 0; i < scanCodes.size(); i++) {
	for (size_t i=0; i<=KEY_MAX; i++) {
	LOGI("(Scan code %d: down=%d)", i, test_bit(i, key_bitmask));
	}
	#endif
	const size_t N = scanCodes.size();
	for (size_t i=0; i<N && i<=KEY_MAX; i++) {
	int32_t sc = scanCodes.itemAt(i);		int32_t sc = scanCodes.itemAt(i);
	//LOGI("Code %d: down=%d", sc, test_bit(sc, key_bitmask));		if (sc >= 0 && sc <= KEY_MAX && test_bit(sc, keyState)) {
	if (sc >= 0 && sc <= KEY_MAX && test_bit(sc, key_bitmask)) {
	return AKEY_STATE_DOWN;		return AKEY_STATE_DOWN;
	}		}
	}		}
	return AKEY_STATE_UP;		return AKEY_STATE_UP;
	}		}
			}
			}
	return AKEY_STATE_UNKNOWN;		return AKEY_STATE_UNKNOWN;
	}		}

	@@ -318,19 +300,13 @@ int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != NULL) {		if (device && test_bit(sw, device->swBitmask)) {
	return getSwitchStateLocked(device, sw);		uint8_t swState[sizeof_bit_array(SW_MAX + 1)];
	}		memset(swState, 0, sizeof(swState));
			if (ioctl(device->fd, EVIOCGSW(sizeof(swState)), swState) >= 0) {
			return test_bit(sw, swState) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
	}		}
	return AKEY_STATE_UNKNOWN;
	}		}

	int32_t EventHub::getSwitchStateLocked(Device* device, int32_t sw) const {
	uint8_t sw_bitmask[sizeof_bit_array(SW_MAX + 1)];
	memset(sw_bitmask, 0, sizeof(sw_bitmask));
	if (ioctl(device->fd,
	EVIOCGSW(sizeof(sw_bitmask)), sw_bitmask) >= 0) {
	return test_bit(sw, sw_bitmask) ? AKEY_STATE_DOWN : AKEY_STATE_UP;
	}		}
	return AKEY_STATE_UNKNOWN;		return AKEY_STATE_UNKNOWN;
	}		}
	@@ -340,18 +316,8 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t*
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != NULL) {		if (device && test_bit(axis, device->absBitmask)) {
	return getAbsoluteAxisValueLocked(device, axis, outValue);
	}
	}
	*outValue = 0;
	return -1;
	}

	status_t EventHub::getAbsoluteAxisValueLocked(Device* device, int32_t axis,
	int32_t* outValue) const {
	struct input_absinfo info;		struct input_absinfo info;

	if(ioctl(device->fd, EVIOCGABS(axis), &info)) {		if(ioctl(device->fd, EVIOCGABS(axis), &info)) {
	LOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",		LOGW("Error reading absolute controller %d for device %s fd %d, errno=%d",
	axis, device->identifier.name.string(), device->fd, errno);		axis, device->identifier.name.string(), device->fd, errno);
	@@ -361,24 +327,17 @@ status_t EventHub::getAbsoluteAxisValueLocked(Device* device, int32_t axis,
	*outValue = info.value;		*outValue = info.value;
	return OK;		return OK;
	}		}
			}
			*outValue = 0;
			return -1;
			}

	bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes,		bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
	const int32_t* keyCodes, uint8_t* outFlags) const {		const int32_t* keyCodes, uint8_t* outFlags) const {
	AutoMutex _l(mLock);		AutoMutex _l(mLock);

	Device* device = getDeviceLocked(deviceId);		Device* device = getDeviceLocked(deviceId);
	if (device != NULL) {		if (device && device->keyMap.haveKeyLayout()) {
	return markSupportedKeyCodesLocked(device, numCodes, keyCodes, outFlags);
	}
	return false;
	}

	bool EventHub::markSupportedKeyCodesLocked(Device* device, size_t numCodes,
	const int32_t* keyCodes, uint8_t* outFlags) const {
	if (!device->keyMap.haveKeyLayout()) {
	return false;
	}

	Vector<int32_t> scanCodes;		Vector<int32_t> scanCodes;
	for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) {		for (size_t codeIndex = 0; codeIndex < numCodes; codeIndex++) {
	scanCodes.clear();		scanCodes.clear();
	@@ -398,6 +357,8 @@ bool EventHub::markSupportedKeyCodesLocked(Device* device, size_t numCodes,
	}		}
	return true;		return true;
	}		}
			return false;
			}

	status_t EventHub::mapKey(int32_t deviceId, int scancode,		status_t EventHub::mapKey(int32_t deviceId, int scancode,
	int32_t* outKeycode, uint32_t* outFlags) const		int32_t* outKeycode, uint32_t* outFlags) const

services/input/EventHub.h

+0 −7

Original line number	Original line	Diff line number	Diff line
	@@ -307,13 +307,6 @@ private:

	bool hasKeycodeLocked(Device* device, int keycode) const;		bool hasKeycodeLocked(Device* device, int keycode) const;

	int32_t getScanCodeStateLocked(Device* device, int32_t scanCode) const;
	int32_t getKeyCodeStateLocked(Device* device, int32_t keyCode) const;
	int32_t getSwitchStateLocked(Device* device, int32_t sw) const;
	int32_t getAbsoluteAxisValueLocked(Device* device, int32_t axis, int32_t* outValue) const;
	bool markSupportedKeyCodesLocked(Device* device, size_t numCodes,
	const int32_t* keyCodes, uint8_t* outFlags) const;

	void loadConfigurationLocked(Device* device);		void loadConfigurationLocked(Device* device);
	status_t loadVirtualKeyMapLocked(Device* device);		status_t loadVirtualKeyMapLocked(Device* device);
	status_t loadKeyMapLocked(Device* device);		status_t loadKeyMapLocked(Device* device);