Merge changes I6618561d,If9479cd9,I3e13894e into pi-dev (1062e857) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/EventControlThread.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -26,8 +26,6 @@

		namespace android {

		class SurfaceFlinger;

		class EventControlThread {
		public:
		virtual ~EventControlThread();

services/surfaceflinger/EventThread.cpp

+10 −8

Original line number	Diff line number	Diff line
		@@ -26,14 +26,12 @@
		#include <cutils/sched_policy.h>

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

		#include <utils/Errors.h>
		#include <utils/String8.h>
		#include <utils/Trace.h>

		#include "EventThread.h"
		#include "SurfaceFlinger.h"

		using namespace std::chrono_literals;

		@@ -47,9 +45,11 @@ EventThread::~EventThread() = default;

		namespace impl {

		EventThread::EventThread(VSyncSource* src, SurfaceFlinger& flinger, bool interceptVSyncs,
		const char* threadName)
		: mVSyncSource(src), mFlinger(flinger), mInterceptVSyncs(interceptVSyncs) {
		EventThread::EventThread(VSyncSource* src, ResyncWithRateLimitCallback resyncWithRateLimitCallback,
		InterceptVSyncsCallback interceptVSyncsCallback, const char* threadName)
		: mVSyncSource(src),
		mResyncWithRateLimitCallback(resyncWithRateLimitCallback),
		mInterceptVSyncsCallback(interceptVSyncsCallback) {
		for (auto& event : mVSyncEvent) {
		event.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
		event.header.id = 0;
		@@ -118,7 +118,9 @@ void EventThread::setVsyncRate(uint32_t count, const sp<EventThread::Connection>
		void EventThread::requestNextVsync(const sp<EventThread::Connection>& connection) {
		std::lock_guard<std::mutex> lock(mMutex);

		mFlinger.resyncWithRateLimit();
		if (mResyncWithRateLimitCallback) {
		mResyncWithRateLimitCallback();
		}

		if (connection->count < 0) {
		connection->count = 0;
		@@ -216,8 +218,8 @@ Vector<sp<EventThread::Connection> > EventThread::waitForEventLocked(
		timestamp = mVSyncEvent[i].header.timestamp;
		if (timestamp) {
		// we have a vsync event to dispatch
		if (mInterceptVSyncs) {
		mFlinger.mInterceptor->saveVSyncEvent(timestamp);
		if (mInterceptVSyncsCallback) {
		mInterceptVSyncsCallback(timestamp);
		}
		*event = mVSyncEvent[i];
		mVSyncEvent[i].header.timestamp = 0;

services/surfaceflinger/EventThread.h

+14 −8

Original line number	Diff line number	Diff line
		@@ -37,6 +37,7 @@
		namespace android {
		// ---------------------------------------------------------------------------

		class EventThreadTest;
		class SurfaceFlinger;
		class String8;

		@@ -82,7 +83,9 @@ class EventThread : public android::EventThread, private VSyncSource::Callback {
		class Connection : public BnDisplayEventConnection {
		public:
		explicit Connection(EventThread* eventThread);
		status_t postEvent(const DisplayEventReceiver::Event& event);
		virtual ~Connection();

		virtual status_t postEvent(const DisplayEventReceiver::Event& event);

		// count >= 1 : continuous event. count is the vsync rate
		// count == 0 : one-shot event that has not fired
		@@ -90,7 +93,6 @@ class EventThread : public android::EventThread, private VSyncSource::Callback {
		int32_t count;

		private:
		virtual ~Connection();
		virtual void onFirstRef();
		status_t stealReceiveChannel(gui::BitTube* outChannel) override;
		status_t setVsyncRate(uint32_t count) override;
		@@ -100,8 +102,11 @@ class EventThread : public android::EventThread, private VSyncSource::Callback {
		};

		public:
		EventThread(VSyncSource* src, SurfaceFlinger& flinger, bool interceptVSyncs,
		const char* threadName);
		using ResyncWithRateLimitCallback = std::function<void()>;
		using InterceptVSyncsCallback = std::function<void(nsecs_t)>;

		EventThread(VSyncSource* src, ResyncWithRateLimitCallback resyncWithRateLimitCallback,
		InterceptVSyncsCallback interceptVSyncsCallback, const char* threadName);
		~EventThread();

		sp<BnDisplayEventConnection> createEventConnection() const override;
		@@ -124,6 +129,8 @@ public:
		void setPhaseOffset(nsecs_t phaseOffset) override;

		private:
		friend EventThreadTest;

		void threadMain();
		Vector<sp<EventThread::Connection>> waitForEventLocked(std::unique_lock<std::mutex>* lock,
		DisplayEventReceiver::Event* event)
		@@ -137,8 +144,9 @@ private:
		void onVSyncEvent(nsecs_t timestamp) override;

		// constants
		VSyncSource* mVSyncSource GUARDED_BY(mMutex) = nullptr;
		SurfaceFlinger& mFlinger;
		VSyncSource* const mVSyncSource GUARDED_BY(mMutex) = nullptr;
		const ResyncWithRateLimitCallback mResyncWithRateLimitCallback;
		const InterceptVSyncsCallback mInterceptVSyncsCallback;

		std::thread mThread;
		mutable std::mutex mMutex;
		@@ -155,8 +163,6 @@ private:

		// for debugging
		bool mDebugVsyncEnabled GUARDED_BY(mMutex) = false;

		const bool mInterceptVSyncs = false;
		};

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

services/surfaceflinger/SurfaceFlinger.cpp

+15 −6

Original line number	Diff line number	Diff line
		@@ -635,13 +635,20 @@ void SurfaceFlinger::init() {
		mEventThreadSource =
		std::make_unique<DispSyncSource>(&mPrimaryDispSync, SurfaceFlinger::vsyncPhaseOffsetNs,
		true, "app");
		mEventThread = std::make_unique<impl::EventThread>(mEventThreadSource.get(), *this, false,
		mEventThread = std::make_unique<impl::EventThread>(mEventThreadSource.get(),
		[this]() { resyncWithRateLimit(); },
		impl::EventThread::InterceptVSyncsCallback(),
		"appEventThread");
		mSfEventThreadSource =
		std::make_unique<DispSyncSource>(&mPrimaryDispSync,
		SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");

		mSFEventThread = std::make_unique<impl::EventThread>(mSfEventThreadSource.get(), *this, true,
		mSFEventThread =
		std::make_unique<impl::EventThread>(mSfEventThreadSource.get(),
		[this]() { resyncWithRateLimit(); },
		[this](nsecs_t timestamp) {
		mInterceptor->saveVSyncEvent(timestamp);
		},
		"sfEventThread");
		mEventQueue->setEventThread(mSFEventThread.get());
		mVsyncModulator.setEventThread(mSFEventThread.get());
		@@ -1131,8 +1138,10 @@ status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
		ALOGV("VSync Injections enabled");
		if (mVSyncInjector.get() == nullptr) {
		mVSyncInjector = std::make_unique<InjectVSyncSource>();
		mInjectorEventThread =
		std::make_unique<impl::EventThread>(mVSyncInjector.get(), *this, false,
		mInjectorEventThread = std::make_unique<
		impl::EventThread>(mVSyncInjector.get(),
		[this]() { resyncWithRateLimit(); },
		impl::EventThread::InterceptVSyncsCallback(),
		"injEventThread");
		}
		mEventQueue->setEventThread(mInjectorEventThread.get());

services/surfaceflinger/tests/unittests/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,8 @@ cc_test {
		srcs: [
		":libsurfaceflinger_sources",
		"DisplayTransactionTest.cpp",
		"EventControlThreadTest.cpp",
		"EventThreadTest.cpp",
		"mock/DisplayHardware/MockComposer.cpp",
		"mock/DisplayHardware/MockDisplaySurface.cpp",
		"mock/gui/MockGraphicBufferConsumer.cpp",