am f37143d8: Merge "Cancel touches as well as pointer gestures." into mnc-dev (9b70ab7a) · Commits · e / os / android_frameworks_native

include/android/keycodes.h

+10 −1

Original line number	Original line	Diff line number	Diff line
	@@ -722,7 +722,16 @@ enum {
	AKEYCODE_NAVIGATE_PREVIOUS = 260,		AKEYCODE_NAVIGATE_PREVIOUS = 260,
	AKEYCODE_NAVIGATE_NEXT = 261,		AKEYCODE_NAVIGATE_NEXT = 261,
	AKEYCODE_NAVIGATE_IN = 262,		AKEYCODE_NAVIGATE_IN = 262,
	AKEYCODE_NAVIGATE_OUT = 263		AKEYCODE_NAVIGATE_OUT = 263,
			/** Primary stem key for Wear
			* Main power/reset button on watch. */
			AKEYCODE_STEM_PRIMARY = 264,
			/** Generic stem key 1 for Wear */
			AKEYCODE_STEM_1 = 265,
			/** Generic stem key 2 for Wear */
			AKEYCODE_STEM_2 = 266,
			/** Generic stem key 3 for Wear */
			AKEYCODE_STEM_3 = 267

	// NOTE: If you add a new keycode here you must also add it to several other files.		// NOTE: If you add a new keycode here you must also add it to several other files.
	// Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.		// Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.

include/input/InputEventLabels.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -303,6 +303,10 @@ static const InputEventLabel KEYCODES[] = {
	DEFINE_KEYCODE(NAVIGATE_NEXT),		DEFINE_KEYCODE(NAVIGATE_NEXT),
	DEFINE_KEYCODE(NAVIGATE_IN),		DEFINE_KEYCODE(NAVIGATE_IN),
	DEFINE_KEYCODE(NAVIGATE_OUT),		DEFINE_KEYCODE(NAVIGATE_OUT),
			DEFINE_KEYCODE(STEM_PRIMARY),
			DEFINE_KEYCODE(STEM_1),
			DEFINE_KEYCODE(STEM_2),
			DEFINE_KEYCODE(STEM_3),

	{ NULL, 0 }		{ NULL, 0 }
	};		};

services/inputflinger/InputReader.cpp

+29 −5

Original line number	Original line	Diff line number	Diff line
	@@ -3860,6 +3860,7 @@ void TouchInputMapper::reset(nsecs_t when) {
	mPointerUsage = POINTER_USAGE_NONE;		mPointerUsage = POINTER_USAGE_NONE;
	mSentHoverEnter = false;		mSentHoverEnter = false;
	mHavePointerIds = false;		mHavePointerIds = false;
			mCurrentMotionAborted = false;
	mDownTime = 0;		mDownTime = 0;

	mCurrentVirtualKey.down = false;		mCurrentVirtualKey.down = false;
	@@ -4087,6 +4088,7 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) {
	mCurrentCookedState.cookedPointerData.touchingIdBits);		mCurrentCookedState.cookedPointerData.touchingIdBits);
	}		}

			if (!mCurrentMotionAborted) {
	dispatchButtonRelease(when, policyFlags);		dispatchButtonRelease(when, policyFlags);
	dispatchHoverExit(when, policyFlags);		dispatchHoverExit(when, policyFlags);
	dispatchTouches(when, policyFlags);		dispatchTouches(when, policyFlags);
	@@ -4094,6 +4096,11 @@ void TouchInputMapper::cookAndDispatch(nsecs_t when) {
	dispatchButtonPress(when, policyFlags);		dispatchButtonPress(when, policyFlags);
	}		}

			if (mCurrentCookedState.cookedPointerData.pointerCount == 0) {
			mCurrentMotionAborted = false;
			}
			}

	// Synthesize key up from raw buttons if needed.		// Synthesize key up from raw buttons if needed.
	synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,		synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,
	policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState);		policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState);
	@@ -4316,6 +4323,22 @@ void TouchInputMapper::dispatchVirtualKey(nsecs_t when, uint32_t policyFlags,
	getListener()->notifyKey(&args);		getListener()->notifyKey(&args);
	}		}

			void TouchInputMapper::abortTouches(nsecs_t when, uint32_t policyFlags) {
			BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;
			if (!currentIdBits.isEmpty()) {
			int32_t metaState = getContext()->getGlobalMetaState();
			int32_t buttonState = mCurrentCookedState.buttonState;
			dispatchMotion(when, policyFlags, mSource, AMOTION_EVENT_ACTION_CANCEL, 0, 0,
			metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
			mCurrentCookedState.cookedPointerData.pointerProperties,
			mCurrentCookedState.cookedPointerData.pointerCoords,
			mCurrentCookedState.cookedPointerData.idToIndex,
			currentIdBits, -1,
			mOrientedXPrecision, mOrientedYPrecision, mDownTime);
			mCurrentMotionAborted = true;
			}
			}

	void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {		void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
	BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;		BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;
	BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits;		BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits;
	@@ -6089,6 +6112,7 @@ void TouchInputMapper::fadePointer() {

	void TouchInputMapper::cancelTouch(nsecs_t when) {		void TouchInputMapper::cancelTouch(nsecs_t when) {
	abortPointerUsage(when, 0 /policyFlags/);		abortPointerUsage(when, 0 /policyFlags/);
			abortTouches(when, 0 /* policyFlags*/);
	}		}

	bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) {		bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) {

services/inputflinger/InputReader.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1469,6 +1469,9 @@ protected:
	// Have we assigned pointer IDs for this stream		// Have we assigned pointer IDs for this stream
	bool mHavePointerIds;		bool mHavePointerIds;

			// Is the current stream of direct touch events aborted
			bool mCurrentMotionAborted;

	// The time the primary pointer last went down.		// The time the primary pointer last went down.
	nsecs_t mDownTime;		nsecs_t mDownTime;

	@@ -1802,6 +1805,7 @@ private:
	void dispatchButtonPress(nsecs_t when, uint32_t policyFlags);		void dispatchButtonPress(nsecs_t when, uint32_t policyFlags);
	const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData);		const BitSet32& findActiveIdBits(const CookedPointerData& cookedPointerData);
	void cookPointerData();		void cookPointerData();
			void abortTouches(nsecs_t when, uint32_t policyFlags);

	void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);		void dispatchPointerUsage(nsecs_t when, uint32_t policyFlags, PointerUsage pointerUsage);
	void abortPointerUsage(nsecs_t when, uint32_t policyFlags);		void abortPointerUsage(nsecs_t when, uint32_t policyFlags);

services/inputflinger/host/InputDriver.cpp

+156 −14

Original line number	Original line	Diff line number	Diff line
	@@ -14,8 +14,11 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#include <functional>
	#include <stdint.h>		#include <stdint.h>
	#include <sys/types.h>		#include <sys/types.h>
			#include <unordered_map>
			#include <vector>

	#define LOG_TAG "InputDriver"		#define LOG_TAG "InputDriver"

	@@ -25,7 +28,9 @@
	#include "InputHost.h"		#include "InputHost.h"

	#include <hardware/input.h>		#include <hardware/input.h>
			#include <input/InputDevice.h>
	#include <utils/Log.h>		#include <utils/Log.h>
			#include <utils/PropertyMap.h>
	#include <utils/String8.h>		#include <utils/String8.h>

	#define INDENT2 " "		#define INDENT2 " "
	@@ -37,6 +42,7 @@ static input_host_callbacks_t kCallbacks = {
	.create_device_definition = create_device_definition,		.create_device_definition = create_device_definition,
	.create_input_report_definition = create_input_report_definition,		.create_input_report_definition = create_input_report_definition,
	.create_output_report_definition = create_output_report_definition,		.create_output_report_definition = create_output_report_definition,
			.free_report_definition = free_report_definition,
	.input_device_definition_add_report = input_device_definition_add_report,		.input_device_definition_add_report = input_device_definition_add_report,
	.input_report_definition_add_collection = input_report_definition_add_collection,		.input_report_definition_add_collection = input_report_definition_add_collection,
	.input_report_definition_declare_usage_int = input_report_definition_declare_usage_int,		.input_report_definition_declare_usage_int = input_report_definition_declare_usage_int,
	@@ -69,78 +75,214 @@ void InputDriver::dump(String8& result) {
	result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());		result.appendFormat(INDENT2 "HAL Input Driver (%s)\n", mName.string());
	}		}

			} // namespace android

			struct input_property_map {
			android::PropertyMap* propertyMap;
			};

			struct input_property {
			android::String8 key;
			android::String8 value;
			};

			struct input_device_identifier {
			const char* name;
			const char* uniqueId;
			input_bus_t bus;
			int32_t vendorId;
			int32_t productId;
			int32_t version;
			};

			struct input_device_definition {
			std::vector<input_report_definition*> reportDefs;
			};

			struct input_device_handle {
			input_device_identifier_t* id;
			input_device_definition_t* def;
			};

			struct input_int_usage {
			input_usage_t usage;
			int32_t min;
			int32_t max;
			float resolution;
			};

			struct input_collection {
			int32_t arity;
			std::vector<input_int_usage> intUsages;
			std::vector<input_usage_t> boolUsages;
			};

			struct InputCollectionIdHasher {
			std::size_t operator()(const input_collection_id& id) const {
			return std::hash<int>()(static_cast<int>(id));
			}
			};

			struct input_report_definition {
			std::unordered_map<input_collection_id_t, input_collection, InputCollectionIdHasher> collections;
			};

	// HAL wrapper functions		// HAL wrapper functions

	input_device_identifier_t* create_device_identifier(input_host_t* host,		namespace android {

			::input_device_identifier_t* create_device_identifier(input_host_t* host,
	const char* name, int32_t product_id, int32_t vendor_id,		const char* name, int32_t product_id, int32_t vendor_id,
	input_bus_t bus, const char* unique_id) {		input_bus_t bus, const char* unique_id) {
	return nullptr;		auto identifier = new ::input_device_identifier {
			.name = name,
			.productId = product_id,
			.vendorId = vendor_id,
			//.bus = bus,
			.uniqueId = unique_id,
			};
			// store this identifier somewhere? in the host?
			return identifier;
	}		}

	input_device_definition_t* create_device_definition(input_host_t* host) {		input_device_definition_t* create_device_definition(input_host_t* host) {
	return nullptr;		return new ::input_device_definition;
	}		}

	input_report_definition_t* create_input_report_definition(input_host_t* host) {		input_report_definition_t* create_input_report_definition(input_host_t* host) {
	return nullptr;		return new ::input_report_definition;
	}		}

	input_report_definition_t* create_output_report_definition(input_host_t* host) {		input_report_definition_t* create_output_report_definition(input_host_t* host) {
	return nullptr;		return new ::input_report_definition;
			}

			void free_report_definition(input_host_t* host, input_report_definition_t* report_def) {
			delete report_def;
	}		}

	void input_device_definition_add_report(input_host_t* host,		void input_device_definition_add_report(input_host_t* host,
	input_device_definition_t* d, input_report_definition_t* r) { }		input_device_definition_t* d, input_report_definition_t* r) {
			d->reportDefs.push_back(r);
			}

	void input_report_definition_add_collection(input_host_t* host,		void input_report_definition_add_collection(input_host_t* host,
	input_report_definition_t* report, input_collection_id_t id, int32_t arity) { }		input_report_definition_t* report, input_collection_id_t id, int32_t arity) {
			report->collections[id] = {.arity = arity};
			}

	void input_report_definition_declare_usage_int(input_host_t* host,		void input_report_definition_declare_usage_int(input_host_t* host,
	input_report_definition_t* report, input_collection_id_t id,		input_report_definition_t* report, input_collection_id_t id,
	input_usage_t usage, int32_t min, int32_t max, float resolution) { }		input_usage_t usage, int32_t min, int32_t max, float resolution) {
			if (report->collections.find(id) != report->collections.end()) {
			report->collections[id].intUsages.push_back({
			.usage = usage, .min = min, .max = max, .resolution = resolution});
			}
			}

	void input_report_definition_declare_usages_bool(input_host_t* host,		void input_report_definition_declare_usages_bool(input_host_t* host,
	input_report_definition_t* report, input_collection_id_t id,		input_report_definition_t* report, input_collection_id_t id,
	input_usage_t* usage, size_t usage_count) { }		input_usage_t* usage, size_t usage_count) {
			if (report->collections.find(id) != report->collections.end()) {
			for (size_t i = 0; i < usage_count; ++i) {
			report->collections[id].boolUsages.push_back(usage[i]);
			}
			}
			}

	input_device_handle_t* register_device(input_host_t* host,		input_device_handle_t* register_device(input_host_t* host,
	input_device_identifier_t* id, input_device_definition_t* d) {		input_device_identifier_t* id, input_device_definition_t* d) {
	return nullptr;		ALOGD("Registering device %s with %d input reports", id->name, d->reportDefs.size());
			return new input_device_handle{ .id = id, .def = d };
	}		}

	input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r) {		input_report_t* input_allocate_report(input_host_t* host, input_report_definition_t* r) {
			ALOGD("Allocating input report for definition %p", r);
	return nullptr;		return nullptr;
	}		}

	void input_report_set_usage_int(input_host_t* host, input_report_t* r,		void input_report_set_usage_int(input_host_t* host, input_report_t* r,
	input_collection_id_t id, input_usage_t usage, int32_t value, int32_t arity_index) { }		input_collection_id_t id, input_usage_t usage, int32_t value, int32_t arity_index) { }

	void input_report_set_usage_bool(input_host_t* host, input_report_t* r,		void input_report_set_usage_bool(input_host_t* host, input_report_t* r,
	input_collection_id_t id, input_usage_t usage, bool value, int32_t arity_index) { }		input_collection_id_t id, input_usage_t usage, bool value, int32_t arity_index) { }

	void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) { }		void report_event(input_host_t* host, input_device_handle_t* d, input_report_t* report) {
			ALOGD("report_event %p for handle %p", report, d);
			}

	input_property_map_t* input_get_device_property_map(input_host_t* host,		input_property_map_t* input_get_device_property_map(input_host_t* host,
	input_device_identifier_t* id) {		input_device_identifier_t* id) {
			InputDeviceIdentifier idi;
			idi.name = id->name;
			idi.uniqueId = id->uniqueId;
			idi.bus = id->bus;
			idi.vendor = id->vendorId;
			idi.product = id->productId;
			idi.version = id->version;

			String8 configFile = getInputDeviceConfigurationFilePathByDeviceIdentifier(
			idi, INPUT_DEVICE_CONFIGURATION_FILE_TYPE_CONFIGURATION);
			if (configFile.isEmpty()) {
			ALOGD("No input device configuration file found for device '%s'.",
			idi.name.string());
			} else {
			auto propMap = new input_property_map_t();
			status_t status = PropertyMap::load(configFile, &propMap->propertyMap);
			if (status) {
			ALOGE("Error loading input device configuration file for device '%s'. "
			"Using default configuration.",
			idi.name.string());
			delete propMap;
			return nullptr;
			}
			return propMap;
			}
	return nullptr;		return nullptr;
	}		}

	input_property_t* input_get_device_property(input_host_t* host, input_property_map_t* map,		input_property_t* input_get_device_property(input_host_t* host, input_property_map_t* map,
	const char* key) {		const char* key) {
			String8 keyString(key);
			if (map != nullptr) {
			if (map->propertyMap->hasProperty(keyString)) {
			auto prop = new input_property_t();
			if (!map->propertyMap->tryGetProperty(keyString, prop->value)) {
			delete prop;
			return nullptr;
			}
			prop->key = keyString;
			return prop;
			}
			}
	return nullptr;		return nullptr;
	}		}

	const char* input_get_property_key(input_host_t* host, input_property_t* property) {		const char* input_get_property_key(input_host_t* host, input_property_t* property) {
			if (property != nullptr) {
			return property->key.string();
			}
	return nullptr;		return nullptr;
	}		}

	const char* input_get_property_value(input_host_t* host, input_property_t* property) {		const char* input_get_property_value(input_host_t* host, input_property_t* property) {
			if (property != nullptr) {
			return property->value.string();
			}
	return nullptr;		return nullptr;
	}		}

	void input_free_device_property(input_host_t* host, input_property_t* property) { }		void input_free_device_property(input_host_t* host, input_property_t* property) {
			if (property != nullptr) {
			delete property;
			}
			}

	void input_free_device_property_map(input_host_t* host, input_property_map_t* map) { }		void input_free_device_property_map(input_host_t* host, input_property_map_t* map) {
			if (map != nullptr) {
			delete map->propertyMap;
			delete map;
			}
			}

	} // namespace android		} // namespace android