Merge "Convert input event type to enum class" into udc-dev am: ae55bae7a8 (a274d867) · Commits · e / os / android_frameworks_native

include/input/Input.h

+23 −8

Original line number	Original line	Diff line number	Diff line
	@@ -210,7 +210,20 @@ vec2 transformWithoutTranslation(const ui::Transform& transform, const vec2& xy)
	*/		*/
	float transformAngle(const ui::Transform& transform, float angleRadians);		float transformAngle(const ui::Transform& transform, float angleRadians);

	const char* inputEventTypeToString(int32_t type);		/**
			* The type of the InputEvent.
			* This should have 1:1 correspondence with the values of anonymous enum defined in input.h.
			*/
			enum class InputEventType {
			KEY = AINPUT_EVENT_TYPE_KEY,
			MOTION = AINPUT_EVENT_TYPE_MOTION,
			FOCUS = AINPUT_EVENT_TYPE_FOCUS,
			CAPTURE = AINPUT_EVENT_TYPE_CAPTURE,
			DRAG = AINPUT_EVENT_TYPE_DRAG,
			TOUCH_MODE = AINPUT_EVENT_TYPE_TOUCH_MODE,
			ftl_first = KEY,
			ftl_last = TOUCH_MODE,
			};

	std::string inputEventSourceToString(int32_t source);		std::string inputEventSourceToString(int32_t source);

	@@ -482,7 +495,7 @@ class InputEvent : public AInputEvent {
	public:		public:
	virtual ~InputEvent() { }		virtual ~InputEvent() { }

	virtual int32_t getType() const = 0;		virtual InputEventType getType() const = 0;

	inline int32_t getId() const { return mId; }		inline int32_t getId() const { return mId; }

	@@ -513,6 +526,8 @@ protected:
	std::array<uint8_t, 32> mHmac;		std::array<uint8_t, 32> mHmac;
	};		};

			std::ostream& operator<<(std::ostream& out, const InputEvent& event);

	/*		/*
	* Key events.		* Key events.
	*/		*/
	@@ -520,7 +535,7 @@ class KeyEvent : public InputEvent {
	public:		public:
	virtual ~KeyEvent() { }		virtual ~KeyEvent() { }

	virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }		virtual InputEventType getType() const { return InputEventType::KEY; }

	inline int32_t getAction() const { return mAction; }		inline int32_t getAction() const { return mAction; }

	@@ -571,7 +586,7 @@ class MotionEvent : public InputEvent {
	public:		public:
	virtual ~MotionEvent() { }		virtual ~MotionEvent() { }

	virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }		virtual InputEventType getType() const { return InputEventType::MOTION; }

	inline int32_t getAction() const { return mAction; }		inline int32_t getAction() const { return mAction; }

	@@ -899,7 +914,7 @@ class FocusEvent : public InputEvent {
	public:		public:
	virtual ~FocusEvent() {}		virtual ~FocusEvent() {}

	virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_FOCUS; }		virtual InputEventType getType() const override { return InputEventType::FOCUS; }

	inline bool getHasFocus() const { return mHasFocus; }		inline bool getHasFocus() const { return mHasFocus; }

	@@ -918,7 +933,7 @@ class CaptureEvent : public InputEvent {
	public:		public:
	virtual ~CaptureEvent() {}		virtual ~CaptureEvent() {}

	virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_CAPTURE; }		virtual InputEventType getType() const override { return InputEventType::CAPTURE; }

	inline bool getPointerCaptureEnabled() const { return mPointerCaptureEnabled; }		inline bool getPointerCaptureEnabled() const { return mPointerCaptureEnabled; }

	@@ -937,7 +952,7 @@ class DragEvent : public InputEvent {
	public:		public:
	virtual ~DragEvent() {}		virtual ~DragEvent() {}

	virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_DRAG; }		virtual InputEventType getType() const override { return InputEventType::DRAG; }

	inline bool isExiting() const { return mIsExiting; }		inline bool isExiting() const { return mIsExiting; }

	@@ -961,7 +976,7 @@ class TouchModeEvent : public InputEvent {
	public:		public:
	virtual ~TouchModeEvent() {}		virtual ~TouchModeEvent() {}

	virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_TOUCH_MODE; }		virtual InputEventType getType() const override { return InputEventType::TOUCH_MODE; }

	inline bool isInTouchMode() const { return mIsInTouchMode; }		inline bool isInTouchMode() const { return mIsInTouchMode; }

libs/gui/tests/EndToEndNativeInputTest.cpp

+9 −9

Original line number	Original line	Diff line number	Diff line
	@@ -164,7 +164,7 @@ public:
	void assertFocusChange(bool hasFocus) {		void assertFocusChange(bool hasFocus) {
	InputEvent *ev = consumeEvent();		InputEvent *ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_FOCUS, ev->getType());		ASSERT_EQ(InputEventType::FOCUS, ev->getType());
	FocusEvent focusEvent = static_cast<FocusEvent >(ev);		FocusEvent focusEvent = static_cast<FocusEvent >(ev);
	EXPECT_EQ(hasFocus, focusEvent->getHasFocus());		EXPECT_EQ(hasFocus, focusEvent->getHasFocus());
	}		}
	@@ -172,7 +172,7 @@ public:
	void expectTap(int x, int y) {		void expectTap(int x, int y) {
	InputEvent* ev = consumeEvent();		InputEvent* ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	MotionEvent* mev = static_cast<MotionEvent*>(ev);		MotionEvent* mev = static_cast<MotionEvent*>(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());
	EXPECT_EQ(x, mev->getX(0));		EXPECT_EQ(x, mev->getX(0));
	@@ -181,7 +181,7 @@ public:

	ev = consumeEvent();		ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	mev = static_cast<MotionEvent*>(ev);		mev = static_cast<MotionEvent*>(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());
	EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);		EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);
	@@ -190,7 +190,7 @@ public:
	void expectTapWithFlag(int x, int y, int32_t flags) {		void expectTapWithFlag(int x, int y, int32_t flags) {
	InputEvent *ev = consumeEvent();		InputEvent *ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	MotionEvent mev = static_cast<MotionEvent >(ev);		MotionEvent mev = static_cast<MotionEvent >(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());
	EXPECT_EQ(x, mev->getX(0));		EXPECT_EQ(x, mev->getX(0));
	@@ -199,7 +199,7 @@ public:

	ev = consumeEvent();		ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	mev = static_cast<MotionEvent *>(ev);		mev = static_cast<MotionEvent *>(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());
	EXPECT_EQ(flags, mev->getFlags() & flags);		EXPECT_EQ(flags, mev->getFlags() & flags);
	@@ -208,7 +208,7 @@ public:
	void expectTapInDisplayCoordinates(int displayX, int displayY) {		void expectTapInDisplayCoordinates(int displayX, int displayY) {
	InputEvent *ev = consumeEvent();		InputEvent *ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	MotionEvent mev = static_cast<MotionEvent >(ev);		MotionEvent mev = static_cast<MotionEvent >(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());
	const PointerCoords &coords = mev->getRawPointerCoords(0 /pointerIndex*/);		const PointerCoords &coords = mev->getRawPointerCoords(0 /pointerIndex*/);
	@@ -218,7 +218,7 @@ public:

	ev = consumeEvent();		ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());		ASSERT_EQ(InputEventType::MOTION, ev->getType());
	mev = static_cast<MotionEvent *>(ev);		mev = static_cast<MotionEvent *>(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());
	EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);		EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);
	@@ -227,7 +227,7 @@ public:
	void expectKey(uint32_t keycode) {		void expectKey(uint32_t keycode) {
	InputEvent *ev = consumeEvent();		InputEvent *ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, ev->getType());		ASSERT_EQ(InputEventType::KEY, ev->getType());
	KeyEvent keyEvent = static_cast<KeyEvent >(ev);		KeyEvent keyEvent = static_cast<KeyEvent >(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, keyEvent->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, keyEvent->getAction());
	EXPECT_EQ(keycode, keyEvent->getKeyCode());		EXPECT_EQ(keycode, keyEvent->getKeyCode());
	@@ -235,7 +235,7 @@ public:

	ev = consumeEvent();		ev = consumeEvent();
	ASSERT_NE(ev, nullptr);		ASSERT_NE(ev, nullptr);
	ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, ev->getType());		ASSERT_EQ(InputEventType::KEY, ev->getType());
	keyEvent = static_cast<KeyEvent *>(ev);		keyEvent = static_cast<KeyEvent *>(ev);
	EXPECT_EQ(AMOTION_EVENT_ACTION_UP, keyEvent->getAction());		EXPECT_EQ(AMOTION_EVENT_ACTION_UP, keyEvent->getAction());
	EXPECT_EQ(keycode, keyEvent->getKeyCode());		EXPECT_EQ(keycode, keyEvent->getKeyCode());

libs/input/Input.cpp

+70 −56

Original line number	Original line	Diff line number	Diff line
	@@ -170,30 +170,6 @@ float transformAngle(const ui::Transform& transform, float angleRadians) {
	return atan2f(transformedPoint.x, -transformedPoint.y);		return atan2f(transformedPoint.x, -transformedPoint.y);
	}		}

	const char* inputEventTypeToString(int32_t type) {
	switch (type) {
	case AINPUT_EVENT_TYPE_KEY: {
	return "KEY";
	}
	case AINPUT_EVENT_TYPE_MOTION: {
	return "MOTION";
	}
	case AINPUT_EVENT_TYPE_FOCUS: {
	return "FOCUS";
	}
	case AINPUT_EVENT_TYPE_CAPTURE: {
	return "CAPTURE";
	}
	case AINPUT_EVENT_TYPE_DRAG: {
	return "DRAG";
	}
	case AINPUT_EVENT_TYPE_TOUCH_MODE: {
	return "TOUCH_MODE";
	}
	}
	return "UNKNOWN";
	}

	std::string inputEventSourceToString(int32_t source) {		std::string inputEventSourceToString(int32_t source) {
	if (source == AINPUT_SOURCE_UNKNOWN) {		if (source == AINPUT_SOURCE_UNKNOWN) {
	return "UNKNOWN";		return "UNKNOWN";
	@@ -287,6 +263,37 @@ int32_t InputEvent::nextId() {
	return idGen.nextId();		return idGen.nextId();
	}		}

			std::ostream& operator<<(std::ostream& out, const InputEvent& event) {
			switch (event.getType()) {
			case InputEventType::KEY: {
			const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);
			out << keyEvent;
			return out;
			}
			case InputEventType::MOTION: {
			const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);
			out << motionEvent;
			return out;
			}
			case InputEventType::FOCUS: {
			out << "FocusEvent";
			return out;
			}
			case InputEventType::CAPTURE: {
			out << "CaptureEvent";
			return out;
			}
			case InputEventType::DRAG: {
			out << "DragEvent";
			return out;
			}
			case InputEventType::TOUCH_MODE: {
			out << "TouchModeEvent";
			return out;
			}
			}
			}

	// --- KeyEvent ---		// --- KeyEvent ---

	const char* KeyEvent::getLabel(int32_t keyCode) {		const char* KeyEvent::getLabel(int32_t keyCode) {
	@@ -1165,38 +1172,44 @@ TouchModeEvent* PooledInputEventFactory::createTouchModeEvent() {

	void PooledInputEventFactory::recycle(InputEvent* event) {		void PooledInputEventFactory::recycle(InputEvent* event) {
	switch (event->getType()) {		switch (event->getType()) {
	case AINPUT_EVENT_TYPE_KEY:		case InputEventType::KEY: {
	if (mKeyEventPool.size() < mMaxPoolSize) {		if (mKeyEventPool.size() < mMaxPoolSize) {
	mKeyEventPool.push(std::unique_ptr<KeyEvent>(static_cast<KeyEvent*>(event)));		mKeyEventPool.push(std::unique_ptr<KeyEvent>(static_cast<KeyEvent*>(event)));
	return;		return;
	}		}
	break;		break;
	case AINPUT_EVENT_TYPE_MOTION:		}
			case InputEventType::MOTION: {
	if (mMotionEventPool.size() < mMaxPoolSize) {		if (mMotionEventPool.size() < mMaxPoolSize) {
	mMotionEventPool.push(std::unique_ptr<MotionEvent>(static_cast<MotionEvent*>(event)));		mMotionEventPool.push(
			std::unique_ptr<MotionEvent>(static_cast<MotionEvent*>(event)));
	return;		return;
	}		}
	break;		break;
	case AINPUT_EVENT_TYPE_FOCUS:		}
			case InputEventType::FOCUS: {
	if (mFocusEventPool.size() < mMaxPoolSize) {		if (mFocusEventPool.size() < mMaxPoolSize) {
	mFocusEventPool.push(std::unique_ptr<FocusEvent>(static_cast<FocusEvent*>(event)));		mFocusEventPool.push(std::unique_ptr<FocusEvent>(static_cast<FocusEvent*>(event)));
	return;		return;
	}		}
	break;		break;
	case AINPUT_EVENT_TYPE_CAPTURE:		}
			case InputEventType::CAPTURE: {
	if (mCaptureEventPool.size() < mMaxPoolSize) {		if (mCaptureEventPool.size() < mMaxPoolSize) {
	mCaptureEventPool.push(		mCaptureEventPool.push(
	std::unique_ptr<CaptureEvent>(static_cast<CaptureEvent*>(event)));		std::unique_ptr<CaptureEvent>(static_cast<CaptureEvent*>(event)));
	return;		return;
	}		}
	break;		break;
	case AINPUT_EVENT_TYPE_DRAG:		}
			case InputEventType::DRAG: {
	if (mDragEventPool.size() < mMaxPoolSize) {		if (mDragEventPool.size() < mMaxPoolSize) {
	mDragEventPool.push(std::unique_ptr<DragEvent>(static_cast<DragEvent*>(event)));		mDragEventPool.push(std::unique_ptr<DragEvent>(static_cast<DragEvent*>(event)));
	return;		return;
	}		}
	break;		break;
	case AINPUT_EVENT_TYPE_TOUCH_MODE:		}
			case InputEventType::TOUCH_MODE: {
	if (mTouchModeEventPool.size() < mMaxPoolSize) {		if (mTouchModeEventPool.size() < mMaxPoolSize) {
	mTouchModeEventPool.push(		mTouchModeEventPool.push(
	std::unique_ptr<TouchModeEvent>(static_cast<TouchModeEvent*>(event)));		std::unique_ptr<TouchModeEvent>(static_cast<TouchModeEvent*>(event)));
	@@ -1204,6 +1217,7 @@ void PooledInputEventFactory::recycle(InputEvent* event) {
	}		}
	break;		break;
	}		}
			}
	delete event;		delete event;
	}		}

libs/input/android/os/InputEventInjectionSync.aidl

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -33,4 +33,7 @@ enum InputEventInjectionSync {

	/* Waits for the input event to be completely processed. */		/* Waits for the input event to be completely processed. */
	WAIT_FOR_FINISHED = 2,		WAIT_FOR_FINISHED = 2,

			ftl_first = NONE,
			ftl_last = WAIT_FOR_FINISHED,
	}		}

libs/input/tests/InputEvent_test.cpp

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -197,7 +197,7 @@ TEST_F(KeyEventTest, Properties) {
	ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);		ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);

	ASSERT_EQ(id, event.getId());		ASSERT_EQ(id, event.getId());
	ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType());		ASSERT_EQ(InputEventType::KEY, event.getType());
	ASSERT_EQ(2, event.getDeviceId());		ASSERT_EQ(2, event.getDeviceId());
	ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());		ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());
	ASSERT_EQ(DISPLAY_ID, event.getDisplayId());		ASSERT_EQ(DISPLAY_ID, event.getDisplayId());
	@@ -346,7 +346,7 @@ void MotionEventTest::initializeEventWithHistory(MotionEvent* event) {
	void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {		void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {
	// Check properties.		// Check properties.
	ASSERT_EQ(mId, event->getId());		ASSERT_EQ(mId, event->getId());
	ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType());		ASSERT_EQ(InputEventType::MOTION, event->getType());
	ASSERT_EQ(2, event->getDeviceId());		ASSERT_EQ(2, event->getDeviceId());
	ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());		ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());
	ASSERT_EQ(DISPLAY_ID, event->getDisplayId());		ASSERT_EQ(DISPLAY_ID, event->getDisplayId());