Merge "Use queue and unique_ptr for pooled events" (b09cb2b4) · Commits · e / os / android_frameworks_native-old

include/input/Input.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -31,8 +31,8 @@
		#include <utils/RefBase.h>
		#include <utils/Timers.h>
		#include <utils/Vector.h>

		#include <limits>
		#include <queue>

		/*
		* Additional private constants not defined in ndk/ui/input.h.
		@@ -709,8 +709,8 @@ public:
		PreallocatedInputEventFactory() { }
		virtual ~PreallocatedInputEventFactory() { }

		virtual KeyEvent* createKeyEvent() { return & mKeyEvent; }
		virtual MotionEvent* createMotionEvent() { return & mMotionEvent; }
		virtual KeyEvent* createKeyEvent() override { return &mKeyEvent; }
		virtual MotionEvent* createMotionEvent() override { return &mMotionEvent; }

		private:
		KeyEvent mKeyEvent;
		@@ -725,16 +725,16 @@ public:
		explicit PooledInputEventFactory(size_t maxPoolSize = 20);
		virtual ~PooledInputEventFactory();

		virtual KeyEvent* createKeyEvent();
		virtual MotionEvent* createMotionEvent();
		virtual KeyEvent* createKeyEvent() override;
		virtual MotionEvent* createMotionEvent() override;

		void recycle(InputEvent* event);

		private:
		const size_t mMaxPoolSize;

		Vector<KeyEvent*> mKeyEventPool;
		Vector<MotionEvent*> mMotionEventPool;
		std::queue<std::unique_ptr<KeyEvent>> mKeyEventPool;
		std::queue<std::unique_ptr<MotionEvent>> mMotionEventPool;
		};

		} // namespace android

+12 −18

Original line number	Diff line number	Diff line
		@@ -595,43 +595,37 @@ PooledInputEventFactory::PooledInputEventFactory(size_t maxPoolSize) :
		}

		PooledInputEventFactory::~PooledInputEventFactory() {
		for (size_t i = 0; i < mKeyEventPool.size(); i++) {
		delete mKeyEventPool.itemAt(i);
		}
		for (size_t i = 0; i < mMotionEventPool.size(); i++) {
		delete mMotionEventPool.itemAt(i);
		}
		}

		KeyEvent* PooledInputEventFactory::createKeyEvent() {
		if (!mKeyEventPool.isEmpty()) {
		KeyEvent* event = mKeyEventPool.top();
		if (mKeyEventPool.empty()) {
		return new KeyEvent();
		}
		KeyEvent* event = mKeyEventPool.front().release();
		mKeyEventPool.pop();
		return event;
		}
		return new KeyEvent();
		}

		MotionEvent* PooledInputEventFactory::createMotionEvent() {
		if (!mMotionEventPool.isEmpty()) {
		MotionEvent* event = mMotionEventPool.top();
		if (mMotionEventPool.empty()) {
		return new MotionEvent();
		}
		MotionEvent* event = mMotionEventPool.front().release();
		mMotionEventPool.pop();
		return event;
		}
		return new MotionEvent();
		}

		void PooledInputEventFactory::recycle(InputEvent* event) {
		switch (event->getType()) {
		case AINPUT_EVENT_TYPE_KEY:
		if (mKeyEventPool.size() < mMaxPoolSize) {
		mKeyEventPool.push(static_cast<KeyEvent*>(event));
		mKeyEventPool.push(std::unique_ptr<KeyEvent>(static_cast<KeyEvent*>(event)));
		return;
		}
		break;
		case AINPUT_EVENT_TYPE_MOTION:
		if (mMotionEventPool.size() < mMaxPoolSize) {
		mMotionEventPool.push(static_cast<MotionEvent*>(event));
		mMotionEventPool.push(std::unique_ptr<MotionEvent>(static_cast<MotionEvent*>(event)));
		return;
		}
		break;