SF: Separate MessageQueue into interface and impl (3fcdef18) · Commits · e / os / android_frameworks_native

services/surfaceflinger/MessageQueue.cpp

+10 −6

Original line number	Original line	Diff line number	Diff line
	@@ -24,6 +24,7 @@
	#include <utils/Timers.h>		#include <utils/Timers.h>
	#include <utils/threads.h>		#include <utils/threads.h>

			#include <gui/DisplayEventReceiver.h>
	#include <gui/IDisplayEventConnection.h>		#include <gui/IDisplayEventConnection.h>

	#include "EventThread.h"		#include "EventThread.h"
	@@ -45,6 +46,12 @@ void MessageBase::handleMessage(const Message&) {

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

			MessageQueue::~MessageQueue() = default;

			// ---------------------------------------------------------------------------

			namespace impl {

	void MessageQueue::Handler::dispatchRefresh() {		void MessageQueue::Handler::dispatchRefresh() {
	if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {		if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {
	mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));		mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));
	@@ -72,17 +79,13 @@ void MessageQueue::Handler::handleMessage(const Message& message) {

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	MessageQueue::MessageQueue() {}

	MessageQueue::~MessageQueue() {}

	void MessageQueue::init(const sp<SurfaceFlinger>& flinger) {		void MessageQueue::init(const sp<SurfaceFlinger>& flinger) {
	mFlinger = flinger;		mFlinger = flinger;
	mLooper = new Looper(true);		mLooper = new Looper(true);
	mHandler = new Handler(*this);		mHandler = new Handler(*this);
	}		}

	void MessageQueue::setEventThread(EventThread* eventThread) {		void MessageQueue::setEventThread(android::EventThread* eventThread) {
	if (mEventThread == eventThread) {		if (mEventThread == eventThread) {
	return;		return;
	}		}
	@@ -159,4 +162,5 @@ int MessageQueue::eventReceiver(int /fd/, int /events/) {

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	}; // namespace android		} // namespace impl
			} // namespace android

services/surfaceflinger/MessageQueue.h

+32 −17

Original line number	Original line	Diff line number	Diff line
	@@ -25,7 +25,7 @@
	#include <utils/Timers.h>		#include <utils/Timers.h>
	#include <utils/threads.h>		#include <utils/threads.h>

	#include <gui/DisplayEventReceiver.h>		#include <gui/IDisplayEventConnection.h>
	#include <private/gui/BitTube.h>		#include <private/gui/BitTube.h>

	#include "Barrier.h"		#include "Barrier.h"
	@@ -34,7 +34,6 @@

	namespace android {		namespace android {

	class IDisplayEventConnection;
	class EventThread;		class EventThread;
	class SurfaceFlinger;		class SurfaceFlinger;

	@@ -77,6 +76,27 @@ private:
	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	class MessageQueue {		class MessageQueue {
			public:
			enum {
			INVALIDATE = 0,
			REFRESH = 1,
			};

			virtual ~MessageQueue();

			virtual void init(const sp<SurfaceFlinger>& flinger) = 0;
			virtual void setEventThread(EventThread* events) = 0;
			virtual void waitMessage() = 0;
			virtual status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0) = 0;
			virtual void invalidate() = 0;
			virtual void refresh() = 0;
			};

			// ---------------------------------------------------------------------------

			namespace impl {

			class MessageQueue final : public android::MessageQueue {
	class Handler : public MessageHandler {		class Handler : public MessageHandler {
	enum { eventMaskInvalidate = 0x1, eventMaskRefresh = 0x2, eventMaskTransaction = 0x4 };		enum { eventMaskInvalidate = 0x1, eventMaskRefresh = 0x2, eventMaskTransaction = 0x4 };
	MessageQueue& mQueue;		MessageQueue& mQueue;
	@@ -93,7 +113,7 @@ class MessageQueue {

	sp<SurfaceFlinger> mFlinger;		sp<SurfaceFlinger> mFlinger;
	sp<Looper> mLooper;		sp<Looper> mLooper;
	EventThread* mEventThread;		android::EventThread* mEventThread;
	sp<IDisplayEventConnection> mEvents;		sp<IDisplayEventConnection> mEvents;
	gui::BitTube mEventTube;		gui::BitTube mEventTube;
	sp<Handler> mHandler;		sp<Handler> mHandler;
	@@ -102,27 +122,22 @@ class MessageQueue {
	int eventReceiver(int fd, int events);		int eventReceiver(int fd, int events);

	public:		public:
	enum {		~MessageQueue() override = default;
	INVALIDATE = 0,		void init(const sp<SurfaceFlinger>& flinger) override;
	REFRESH = 1,		void setEventThread(android::EventThread* events) override;
	};

	MessageQueue();
	~MessageQueue();
	void init(const sp<SurfaceFlinger>& flinger);
	void setEventThread(EventThread* events);

	void waitMessage();		void waitMessage() override;
	status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0);		status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0) override;

	// sends INVALIDATE message at next VSYNC		// sends INVALIDATE message at next VSYNC
	void invalidate();		void invalidate() override;
	// sends REFRESH message at next VSYNC		// sends REFRESH message at next VSYNC
	void refresh();		void refresh() override;
	};		};

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

	}; // namespace android		} // namespace impl
			} // namespace android

	#endif /* ANDROID_MESSAGE_QUEUE_H */		#endif /* ANDROID_MESSAGE_QUEUE_H */

services/surfaceflinger/SurfaceFlinger.cpp

+11 −10

Original line number	Original line	Diff line number	Diff line
	@@ -278,7 +278,7 @@ SurfaceFlinger::SurfaceFlinger() : SurfaceFlinger(SkipInitialization) {

	void SurfaceFlinger::onFirstRef()		void SurfaceFlinger::onFirstRef()
	{		{
	mEventQueue.init(this);		mEventQueue->init(this);
	}		}

	SurfaceFlinger::~SurfaceFlinger()		SurfaceFlinger::~SurfaceFlinger()
	@@ -584,9 +584,10 @@ void SurfaceFlinger::init() {
	mSfEventThreadSource =		mSfEventThreadSource =
	std::make_unique<DispSyncSource>(&mPrimaryDispSync,		std::make_unique<DispSyncSource>(&mPrimaryDispSync,
	SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");		SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");

	mSFEventThread = std::make_unique<impl::EventThread>(mSfEventThreadSource.get(), *this, true,		mSFEventThread = std::make_unique<impl::EventThread>(mSfEventThreadSource.get(), *this, true,
	"sfEventThread");		"sfEventThread");
	mEventQueue.setEventThread(mSFEventThread.get());		mEventQueue->setEventThread(mSFEventThread.get());

	// Get a RenderEngine for the given display / config (can't fail)		// Get a RenderEngine for the given display / config (can't fail)
	getBE().mRenderEngine =		getBE().mRenderEngine =
	@@ -1075,10 +1076,10 @@ status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
	std::make_unique<impl::EventThread>(mVSyncInjector.get(), *this, false,		std::make_unique<impl::EventThread>(mVSyncInjector.get(), *this, false,
	"injEventThread");		"injEventThread");
	}		}
	mEventQueue.setEventThread(mInjectorEventThread.get());		mEventQueue->setEventThread(mInjectorEventThread.get());
	} else {		} else {
	ALOGV("VSync Injections disabled");		ALOGV("VSync Injections disabled");
	mEventQueue.setEventThread(mSFEventThread.get());		mEventQueue->setEventThread(mSFEventThread.get());
	}		}

	mInjectVSyncs = enable;		mInjectVSyncs = enable;
	@@ -1143,30 +1144,30 @@ sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection(
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	void SurfaceFlinger::waitForEvent() {		void SurfaceFlinger::waitForEvent() {
	mEventQueue.waitMessage();		mEventQueue->waitMessage();
	}		}

	void SurfaceFlinger::signalTransaction() {		void SurfaceFlinger::signalTransaction() {
	mEventQueue.invalidate();		mEventQueue->invalidate();
	}		}

	void SurfaceFlinger::signalLayerUpdate() {		void SurfaceFlinger::signalLayerUpdate() {
	mEventQueue.invalidate();		mEventQueue->invalidate();
	}		}

	void SurfaceFlinger::signalRefresh() {		void SurfaceFlinger::signalRefresh() {
	mRefreshPending = true;		mRefreshPending = true;
	mEventQueue.refresh();		mEventQueue->refresh();
	}		}

	status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,		status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
	nsecs_t reltime, uint32_t /* flags */) {		nsecs_t reltime, uint32_t /* flags */) {
	return mEventQueue.postMessage(msg, reltime);		return mEventQueue->postMessage(msg, reltime);
	}		}

	status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,		status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
	nsecs_t reltime, uint32_t /* flags */) {		nsecs_t reltime, uint32_t /* flags */) {
	status_t res = mEventQueue.postMessage(msg, reltime);		status_t res = mEventQueue->postMessage(msg, reltime);
	if (res == NO_ERROR) {		if (res == NO_ERROR) {
	msg->wait();		msg->wait();
	}		}

services/surfaceflinger/SurfaceFlinger.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -784,7 +784,7 @@ private:
	bool mLayerTripleBufferingDisabled = false;		bool mLayerTripleBufferingDisabled = false;

	// these are thread safe		// these are thread safe
	mutable MessageQueue mEventQueue;		mutable std::unique_ptr<MessageQueue> mEventQueue{std::make_unique<impl::MessageQueue>()};
	FrameTracker mAnimFrameTracker;		FrameTracker mAnimFrameTracker;
	DispSync mPrimaryDispSync;		DispSync mPrimaryDispSync;