am 89ee578b: am fd035829: Add initial gamepad support. (94eed383) · Commits · e / os / android_frameworks_native

include/ui/InputDevice.h

0 → 100644

+338 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2010 The Android Open Source Project
			*
			* Licensed under the Apache License, Version 2.0 (the "License");
			* you may not use this file except in compliance with the License.
			* You may obtain a copy of the License at
			*
			* http://www.apache.org/licenses/LICENSE-2.0
			*
			* Unless required by applicable law or agreed to in writing, software
			* distributed under the License is distributed on an "AS IS" BASIS,
			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			* See the License for the specific language governing permissions and
			* limitations under the License.
			*/

			#ifndef _UI_INPUT_DEVICE_H
			#define _UI_INPUT_DEVICE_H

			#include <ui/EventHub.h>
			#include <ui/Input.h>
			#include <utils/KeyedVector.h>
			#include <utils/threads.h>
			#include <utils/Timers.h>
			#include <utils/RefBase.h>
			#include <utils/String8.h>
			#include <utils/BitSet.h>

			#include <stddef.h>
			#include <unistd.h>

			/* Maximum pointer id value supported.
			* (This is limited by our use of BitSet32 to track pointer assignments.) */
			#define MAX_POINTER_ID 31

			/* Maximum number of historical samples to average. */
			#define AVERAGING_HISTORY_SIZE 5


			namespace android {

			extern int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState);
			extern int32_t rotateKeyCode(int32_t keyCode, int32_t orientation);

			/*
			* An input device structure tracks the state of a single input device.
			*
			* This structure is only used by ReaderThread and is not intended to be shared with
			* DispatcherThread (because that would require locking). This works out fine because
			* DispatcherThread is only interested in cooked event data anyways and does not need
			* any of the low-level data from InputDevice.
			*/
			struct InputDevice {
			struct AbsoluteAxisInfo {
			bool valid; // set to true if axis parameters are known, false otherwise

			int32_t minValue; // minimum value
			int32_t maxValue; // maximum value
			int32_t range; // range of values, equal to maxValue - minValue
			int32_t flat; // center flat position, eg. flat == 8 means center is between -8 and 8
			int32_t fuzz; // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise
			};

			struct VirtualKey {
			int32_t keyCode;
			int32_t scanCode;
			uint32_t flags;

			// computed hit box, specified in touch screen coords based on known display size
			int32_t hitLeft;
			int32_t hitTop;
			int32_t hitRight;
			int32_t hitBottom;

			inline bool isHit(int32_t x, int32_t y) const {
			return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
			}
			};

			struct KeyboardState {
			struct Current {
			int32_t metaState;
			nsecs_t downTime; // time of most recent key down
			} current;

			void reset();
			};

			struct TrackballState {
			struct Accumulator {
			enum {
			FIELD_BTN_MOUSE = 1,
			FIELD_REL_X = 2,
			FIELD_REL_Y = 4
			};

			uint32_t fields;

			bool btnMouse;
			int32_t relX;
			int32_t relY;

			inline void clear() {
			fields = 0;
			}

			inline bool isDirty() {
			return fields != 0;
			}
			} accumulator;

			struct Current {
			bool down;
			nsecs_t downTime;
			} current;

			struct Precalculated {
			float xScale;
			float yScale;
			float xPrecision;
			float yPrecision;
			} precalculated;

			void reset();
			};

			struct SingleTouchScreenState {
			struct Accumulator {
			enum {
			FIELD_BTN_TOUCH = 1,
			FIELD_ABS_X = 2,
			FIELD_ABS_Y = 4,
			FIELD_ABS_PRESSURE = 8,
			FIELD_ABS_TOOL_WIDTH = 16
			};

			uint32_t fields;

			bool btnTouch;
			int32_t absX;
			int32_t absY;
			int32_t absPressure;
			int32_t absToolWidth;

			inline void clear() {
			fields = 0;
			}

			inline bool isDirty() {
			return fields != 0;
			}
			} accumulator;

			struct Current {
			bool down;
			int32_t x;
			int32_t y;
			int32_t pressure;
			int32_t size;
			} current;

			void reset();
			};

			struct MultiTouchScreenState {
			struct Accumulator {
			enum {
			FIELD_ABS_MT_POSITION_X = 1,
			FIELD_ABS_MT_POSITION_Y = 2,
			FIELD_ABS_MT_TOUCH_MAJOR = 4,
			FIELD_ABS_MT_WIDTH_MAJOR = 8,
			FIELD_ABS_MT_TRACKING_ID = 16
			};

			uint32_t pointerCount;
			struct Pointer {
			uint32_t fields;

			int32_t absMTPositionX;
			int32_t absMTPositionY;
			int32_t absMTTouchMajor;
			int32_t absMTWidthMajor;
			int32_t absMTTrackingId;

			inline void clear() {
			fields = 0;
			}
			} pointers[MAX_POINTERS + 1]; // + 1 to remove the need for extra range checks

			inline void clear() {
			pointerCount = 0;
			pointers[0].clear();
			}

			inline bool isDirty() {
			return pointerCount != 0;
			}
			} accumulator;

			void reset();
			};

			struct PointerData {
			uint32_t id;
			int32_t x;
			int32_t y;
			int32_t pressure;
			int32_t size;
			};

			struct TouchData {
			uint32_t pointerCount;
			PointerData pointers[MAX_POINTERS];
			BitSet32 idBits;
			uint32_t idToIndex[MAX_POINTER_ID + 1];

			void copyFrom(const TouchData& other);

			inline void clear() {
			pointerCount = 0;
			idBits.clear();
			}
			};

			// common state used for both single-touch and multi-touch screens after the initial
			// touch decoding has been performed
			struct TouchScreenState {
			Vector<VirtualKey> virtualKeys;

			struct Parameters {
			bool useBadTouchFilter;
			bool useJumpyTouchFilter;
			bool useAveragingTouchFilter;

			AbsoluteAxisInfo xAxis;
			AbsoluteAxisInfo yAxis;
			AbsoluteAxisInfo pressureAxis;
			AbsoluteAxisInfo sizeAxis;
			} parameters;

			// The touch data of the current sample being processed.
			TouchData currentTouch;

			// The touch data of the previous sample that was processed. This is updated
			// incrementally while the current sample is being processed.
			TouchData lastTouch;

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

			struct CurrentVirtualKeyState {
			enum Status {
			STATUS_UP,
			STATUS_DOWN,
			STATUS_CANCELED
			};

			Status status;
			nsecs_t downTime;
			int32_t keyCode;
			int32_t scanCode;
			} currentVirtualKey;

			struct AveragingTouchFilterState {
			// Individual history tracks are stored by pointer id
			uint32_t historyStart[MAX_POINTERS];
			uint32_t historyEnd[MAX_POINTERS];
			struct {
			struct {
			int32_t x;
			int32_t y;
			int32_t pressure;
			} pointers[MAX_POINTERS];
			} historyData[AVERAGING_HISTORY_SIZE];
			} averagingTouchFilter;

			struct JumpTouchFilterState {
			int32_t jumpyPointsDropped;
			} jumpyTouchFilter;

			struct Precalculated {
			int32_t xOrigin;
			float xScale;

			int32_t yOrigin;
			float yScale;

			int32_t pressureOrigin;
			float pressureScale;

			int32_t sizeOrigin;
			float sizeScale;
			} precalculated;

			void reset();

			bool applyBadTouchFilter();
			bool applyJumpyTouchFilter();
			void applyAveragingTouchFilter();
			void calculatePointerIds();

			bool isPointInsideDisplay(int32_t x, int32_t y) const;
			const InputDevice::VirtualKey* findVirtualKeyHit() const;
			};

			InputDevice(int32_t id, uint32_t classes, String8 name);

			int32_t id;
			uint32_t classes;
			String8 name;
			bool ignored;

			KeyboardState keyboard;
			TrackballState trackball;
			TouchScreenState touchScreen;
			union {
			SingleTouchScreenState singleTouchScreen;
			MultiTouchScreenState multiTouchScreen;
			};

			void reset();

			inline bool isKeyboard() const { return classes & INPUT_DEVICE_CLASS_KEYBOARD; }
			inline bool isAlphaKey() const { return classes & INPUT_DEVICE_CLASS_ALPHAKEY; }
			inline bool isTrackball() const { return classes & INPUT_DEVICE_CLASS_TRACKBALL; }
			inline bool isDPad() const { return classes & INPUT_DEVICE_CLASS_DPAD; }
			inline bool isSingleTouchScreen() const { return (classes
			& (INPUT_DEVICE_CLASS_TOUCHSCREEN \| INPUT_DEVICE_CLASS_TOUCHSCREEN_MT))
			== INPUT_DEVICE_CLASS_TOUCHSCREEN; }
			inline bool isMultiTouchScreen() const { return classes
			& INPUT_DEVICE_CLASS_TOUCHSCREEN_MT; }
			inline bool isTouchScreen() const { return classes
			& (INPUT_DEVICE_CLASS_TOUCHSCREEN \| INPUT_DEVICE_CLASS_TOUCHSCREEN_MT); }
			};

			} // namespace android

			#endif // _UI_INPUT_DEVICE_H

include/ui/InputReader.h

+1 −303

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,7 @@

	#include <ui/EventHub.h>		#include <ui/EventHub.h>
	#include <ui/Input.h>		#include <ui/Input.h>
			#include <ui/InputDevice.h>
	#include <ui/InputDispatcher.h>		#include <ui/InputDispatcher.h>
	#include <utils/KeyedVector.h>		#include <utils/KeyedVector.h>
	#include <utils/threads.h>		#include <utils/threads.h>
	@@ -30,311 +31,8 @@
	#include <stddef.h>		#include <stddef.h>
	#include <unistd.h>		#include <unistd.h>

	/* Maximum pointer id value supported.
	* (This is limited by our use of BitSet32 to track pointer assignments.) */
	#define MAX_POINTER_ID 32

	/* Maximum number of historical samples to average. */
	#define AVERAGING_HISTORY_SIZE 5


	namespace android {		namespace android {

	extern int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState);
	extern int32_t rotateKeyCode(int32_t keyCode, int32_t orientation);

	/*
	* An input device structure tracks the state of a single input device.
	*
	* This structure is only used by ReaderThread and is not intended to be shared with
	* DispatcherThread (because that would require locking). This works out fine because
	* DispatcherThread is only interested in cooked event data anyways and does not need
	* any of the low-level data from InputDevice.
	*/
	struct InputDevice {
	struct AbsoluteAxisInfo {
	bool valid; // set to true if axis parameters are known, false otherwise

	int32_t minValue; // minimum value
	int32_t maxValue; // maximum value
	int32_t range; // range of values, equal to maxValue - minValue
	int32_t flat; // center flat position, eg. flat == 8 means center is between -8 and 8
	int32_t fuzz; // error tolerance, eg. fuzz == 4 means value is +/- 4 due to noise
	};

	struct VirtualKey {
	int32_t keyCode;
	int32_t scanCode;
	uint32_t flags;

	// computed hit box, specified in touch screen coords based on known display size
	int32_t hitLeft;
	int32_t hitTop;
	int32_t hitRight;
	int32_t hitBottom;

	inline bool isHit(int32_t x, int32_t y) const {
	return x >= hitLeft && x <= hitRight && y >= hitTop && y <= hitBottom;
	}
	};

	struct KeyboardState {
	struct Current {
	int32_t metaState;
	nsecs_t downTime; // time of most recent key down
	} current;

	void reset();
	};

	struct TrackballState {
	struct Accumulator {
	enum {
	FIELD_BTN_MOUSE = 1,
	FIELD_REL_X = 2,
	FIELD_REL_Y = 4
	};

	uint32_t fields;

	bool btnMouse;
	int32_t relX;
	int32_t relY;

	inline void clear() {
	fields = 0;
	}

	inline bool isDirty() {
	return fields != 0;
	}
	} accumulator;

	struct Current {
	bool down;
	nsecs_t downTime;
	} current;

	struct Precalculated {
	float xScale;
	float yScale;
	float xPrecision;
	float yPrecision;
	} precalculated;

	void reset();
	};

	struct SingleTouchScreenState {
	struct Accumulator {
	enum {
	FIELD_BTN_TOUCH = 1,
	FIELD_ABS_X = 2,
	FIELD_ABS_Y = 4,
	FIELD_ABS_PRESSURE = 8,
	FIELD_ABS_TOOL_WIDTH = 16
	};

	uint32_t fields;

	bool btnTouch;
	int32_t absX;
	int32_t absY;
	int32_t absPressure;
	int32_t absToolWidth;

	inline void clear() {
	fields = 0;
	}

	inline bool isDirty() {
	return fields != 0;
	}
	} accumulator;

	struct Current {
	bool down;
	int32_t x;
	int32_t y;
	int32_t pressure;
	int32_t size;
	} current;

	void reset();
	};

	struct MultiTouchScreenState {
	struct Accumulator {
	enum {
	FIELD_ABS_MT_POSITION_X = 1,
	FIELD_ABS_MT_POSITION_Y = 2,
	FIELD_ABS_MT_TOUCH_MAJOR = 4,
	FIELD_ABS_MT_WIDTH_MAJOR = 8,
	FIELD_ABS_MT_TRACKING_ID = 16
	};

	uint32_t pointerCount;
	struct Pointer {
	uint32_t fields;

	int32_t absMTPositionX;
	int32_t absMTPositionY;
	int32_t absMTTouchMajor;
	int32_t absMTWidthMajor;
	int32_t absMTTrackingId;

	inline void clear() {
	fields = 0;
	}
	} pointers[MAX_POINTERS + 1]; // + 1 to remove the need for extra range checks

	inline void clear() {
	pointerCount = 0;
	pointers[0].clear();
	}

	inline bool isDirty() {
	return pointerCount != 0;
	}
	} accumulator;

	void reset();
	};

	struct PointerData {
	uint32_t id;
	int32_t x;
	int32_t y;
	int32_t pressure;
	int32_t size;
	};

	struct TouchData {
	uint32_t pointerCount;
	PointerData pointers[MAX_POINTERS];
	BitSet32 idBits;
	uint32_t idToIndex[MAX_POINTER_ID];

	void copyFrom(const TouchData& other);

	inline void clear() {
	pointerCount = 0;
	idBits.clear();
	}
	};

	// common state used for both single-touch and multi-touch screens after the initial
	// touch decoding has been performed
	struct TouchScreenState {
	Vector<VirtualKey> virtualKeys;

	struct Parameters {
	bool useBadTouchFilter;
	bool useJumpyTouchFilter;
	bool useAveragingTouchFilter;

	AbsoluteAxisInfo xAxis;
	AbsoluteAxisInfo yAxis;
	AbsoluteAxisInfo pressureAxis;
	AbsoluteAxisInfo sizeAxis;
	} parameters;

	// The touch data of the current sample being processed.
	TouchData currentTouch;

	// The touch data of the previous sample that was processed. This is updated
	// incrementally while the current sample is being processed.
	TouchData lastTouch;

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

	struct CurrentVirtualKeyState {
	enum Status {
	STATUS_UP,
	STATUS_DOWN,
	STATUS_CANCELED
	};

	Status status;
	nsecs_t downTime;
	int32_t keyCode;
	int32_t scanCode;
	} currentVirtualKey;

	struct AveragingTouchFilterState {
	// Individual history tracks are stored by pointer id
	uint32_t historyStart[MAX_POINTERS];
	uint32_t historyEnd[MAX_POINTERS];
	struct {
	struct {
	int32_t x;
	int32_t y;
	int32_t pressure;
	} pointers[MAX_POINTERS];
	} historyData[AVERAGING_HISTORY_SIZE];
	} averagingTouchFilter;

	struct JumpTouchFilterState {
	int32_t jumpyPointsDropped;
	} jumpyTouchFilter;

	struct Precalculated {
	int32_t xOrigin;
	float xScale;

	int32_t yOrigin;
	float yScale;

	int32_t pressureOrigin;
	float pressureScale;

	int32_t sizeOrigin;
	float sizeScale;
	} precalculated;

	void reset();

	bool applyBadTouchFilter();
	bool applyJumpyTouchFilter();
	void applyAveragingTouchFilter();
	void calculatePointerIds();

	bool isPointInsideDisplay(int32_t x, int32_t y) const;
	const InputDevice::VirtualKey* findVirtualKeyHit() const;
	};

	InputDevice(int32_t id, uint32_t classes, String8 name);

	int32_t id;
	uint32_t classes;
	String8 name;
	bool ignored;

	KeyboardState keyboard;
	TrackballState trackball;
	TouchScreenState touchScreen;
	union {
	SingleTouchScreenState singleTouchScreen;
	MultiTouchScreenState multiTouchScreen;
	};

	void reset();

	inline bool isKeyboard() const { return classes & INPUT_DEVICE_CLASS_KEYBOARD; }
	inline bool isAlphaKey() const { return classes & INPUT_DEVICE_CLASS_ALPHAKEY; }
	inline bool isTrackball() const { return classes & INPUT_DEVICE_CLASS_TRACKBALL; }
	inline bool isDPad() const { return classes & INPUT_DEVICE_CLASS_DPAD; }
	inline bool isSingleTouchScreen() const { return (classes
	& (INPUT_DEVICE_CLASS_TOUCHSCREEN \| INPUT_DEVICE_CLASS_TOUCHSCREEN_MT))
	== INPUT_DEVICE_CLASS_TOUCHSCREEN; }
	inline bool isMultiTouchScreen() const { return classes
	& INPUT_DEVICE_CLASS_TOUCHSCREEN_MT; }
	inline bool isTouchScreen() const { return classes
	& (INPUT_DEVICE_CLASS_TOUCHSCREEN \| INPUT_DEVICE_CLASS_TOUCHSCREEN_MT); }
	};


	/*		/*
	* Input reader policy interface.		* Input reader policy interface.
	*		*

include/ui/KeycodeLabels.h

+19 −106

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,8 @@
	#ifndef _UI_KEYCODE_LABELS_H		#ifndef _UI_KEYCODE_LABELS_H
	#define _UI_KEYCODE_LABELS_H		#define _UI_KEYCODE_LABELS_H

			#include <android/keycodes.h>

	struct KeycodeLabel {		struct KeycodeLabel {
	const char *literal;		const char *literal;
	int value;		int value;
	@@ -118,117 +120,28 @@ static const KeycodeLabel KEYCODES[] = {
	{ "PAGE_DOWN", 93 },		{ "PAGE_DOWN", 93 },
	{ "PICTSYMBOLS", 94 },		{ "PICTSYMBOLS", 94 },
	{ "SWITCH_CHARSET", 95 },		{ "SWITCH_CHARSET", 95 },
			{ "BUTTON_A", 96 },
			{ "BUTTON_B", 97 },
			{ "BUTTON_C", 98 },
			{ "BUTTON_X", 99 },
			{ "BUTTON_Y", 100 },
			{ "BUTTON_Z", 101 },
			{ "BUTTON_L1", 102 },
			{ "BUTTON_R1", 103 },
			{ "BUTTON_L2", 104 },
			{ "BUTTON_R2", 105 },
			{ "BUTTON_THUMBL", 106 },
			{ "BUTTON_THUMBR", 107 },
			{ "BUTTON_START", 108 },
			{ "BUTTON_SELECT", 109 },
			{ "BUTTON_MODE", 110 },

	// NOTE: If you add a new keycode here you must also add it to:		// NOTE: If you add a new keycode here you must also add it to several other files.
	// (enum KeyCode, in this file)		// Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.
	// frameworks/base/core/java/android/view/KeyEvent.java
	// tools/puppet_master/PuppetMaster.nav_keys.py
	// frameworks/base/core/res/res/values/attrs.xml

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

	// These constants need to match the above mappings.
	typedef enum KeyCode {
	kKeyCodeUnknown = 0,

	kKeyCodeSoftLeft = 1,
	kKeyCodeSoftRight = 2,
	kKeyCodeHome = 3,
	kKeyCodeBack = 4,
	kKeyCodeCall = 5,
	kKeyCodeEndCall = 6,
	kKeyCode0 = 7,
	kKeyCode1 = 8,
	kKeyCode2 = 9,
	kKeyCode3 = 10,
	kKeyCode4 = 11,
	kKeyCode5 = 12,
	kKeyCode6 = 13,
	kKeyCode7 = 14,
	kKeyCode8 = 15,
	kKeyCode9 = 16,
	kKeyCodeStar = 17,
	kKeyCodePound = 18,
	kKeyCodeDpadUp = 19,
	kKeyCodeDpadDown = 20,
	kKeyCodeDpadLeft = 21,
	kKeyCodeDpadRight = 22,
	kKeyCodeDpadCenter = 23,
	kKeyCodeVolumeUp = 24,
	kKeyCodeVolumeDown = 25,
	kKeyCodePower = 26,
	kKeyCodeCamera = 27,
	kKeyCodeClear = 28,
	kKeyCodeA = 29,
	kKeyCodeB = 30,
	kKeyCodeC = 31,
	kKeyCodeD = 32,
	kKeyCodeE = 33,
	kKeyCodeF = 34,
	kKeyCodeG = 35,
	kKeyCodeH = 36,
	kKeyCodeI = 37,
	kKeyCodeJ = 38,
	kKeyCodeK = 39,
	kKeyCodeL = 40,
	kKeyCodeM = 41,
	kKeyCodeN = 42,
	kKeyCodeO = 43,
	kKeyCodeP = 44,
	kKeyCodeQ = 45,
	kKeyCodeR = 46,
	kKeyCodeS = 47,
	kKeyCodeT = 48,
	kKeyCodeU = 49,
	kKeyCodeV = 50,
	kKeyCodeW = 51,
	kKeyCodeX = 52,
	kKeyCodeY = 53,
	kKeyCodeZ = 54,
	kKeyCodeComma = 55,
	kKeyCodePeriod = 56,
	kKeyCodeAltLeft = 57,
	kKeyCodeAltRight = 58,
	kKeyCodeShiftLeft = 59,
	kKeyCodeShiftRight = 60,
	kKeyCodeTab = 61,
	kKeyCodeSpace = 62,
	kKeyCodeSym = 63,
	kKeyCodeExplorer = 64,
	kKeyCodeEnvelope = 65,
	kKeyCodeNewline = 66,
	kKeyCodeDel = 67,
	kKeyCodeGrave = 68,
	kKeyCodeMinus = 69,
	kKeyCodeEquals = 70,
	kKeyCodeLeftBracket = 71,
	kKeyCodeRightBracket = 72,
	kKeyCodeBackslash = 73,
	kKeyCodeSemicolon = 74,
	kKeyCodeApostrophe = 75,
	kKeyCodeSlash = 76,
	kKeyCodeAt = 77,
	kKeyCodeNum = 78,
	kKeyCodeHeadSetHook = 79,
	kKeyCodeFocus = 80,
	kKeyCodePlus = 81,
	kKeyCodeMenu = 82,
	kKeyCodeNotification = 83,
	kKeyCodeSearch = 84,
	kKeyCodePlayPause = 85,
	kKeyCodeStop = 86,
	kKeyCodeNextSong = 87,
	kKeyCodePreviousSong = 88,
	kKeyCodeRewind = 89,
	kKeyCodeForward = 90,
	kKeyCodeMute = 91,
	kKeyCodePageUp = 92,
	kKeyCodePageDown = 93,
	kKeyCodePictSymbols = 94,
	kKeyCodeSwitchCharset = 95
	} KeyCode;

	static const KeycodeLabel FLAGS[] = {		static const KeycodeLabel FLAGS[] = {
	{ "WAKE", 0x00000001 },		{ "WAKE", 0x00000001 },
	{ "WAKE_DROPPED", 0x00000002 },		{ "WAKE_DROPPED", 0x00000002 },

libs/ui/Android.mk

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -12,6 +12,7 @@ LOCAL_SRC_FILES:= \
	KeyLayoutMap.cpp \		KeyLayoutMap.cpp \
	KeyCharacterMap.cpp \		KeyCharacterMap.cpp \
	Input.cpp \		Input.cpp \
			InputDevice.cpp \
	InputDispatcher.cpp \		InputDispatcher.cpp \
	InputManager.cpp \		InputManager.cpp \
	InputReader.cpp \		InputReader.cpp \
	@@ -38,3 +39,13 @@ ifeq ($(TARGET_SIMULATOR),true)
	endif		endif

	include $(BUILD_SHARED_LIBRARY)		include $(BUILD_SHARED_LIBRARY)


			# Include subdirectory makefiles
			# ============================================================

			# If we're building with ONE_SHOT_MAKEFILE (mm, mmm), then what the framework
			# team really wants is to build the stuff defined by this makefile.
			ifeq (,$(ONE_SHOT_MAKEFILE))
			include $(call first-makefiles-under,$(LOCAL_PATH))
			endif

libs/ui/EventHub.cpp

+79 −45

File changed.

Preview size limit exceeded, changes collapsed.