Merge "Reland Consolidate flags in Transaction" into main (e96941d3) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/gui/SurfaceComposerClient.cpp

+15 −33

Original line number	Diff line number	Diff line
		@@ -829,9 +829,7 @@ SurfaceComposerClient::Transaction::Transaction() {

		SurfaceComposerClient::Transaction::Transaction(const Transaction& other)
		: mId(other.mId),
		mAnimation(other.mAnimation),
		mEarlyWakeupStart(other.mEarlyWakeupStart),
		mEarlyWakeupEnd(other.mEarlyWakeupEnd),
		mFlags(other.mFlags),
		mMayContainBuffer(other.mMayContainBuffer),
		mDesiredPresentTime(other.mDesiredPresentTime),
		mIsAutoTimestamp(other.mIsAutoTimestamp),
		@@ -868,9 +866,7 @@ SurfaceComposerClient::Transaction::createFromParcel(const Parcel* parcel) {

		status_t SurfaceComposerClient::Transaction::readFromParcel(const Parcel* parcel) {
		const uint64_t transactionId = parcel->readUint64();
		const bool animation = parcel->readBool();
		const bool earlyWakeupStart = parcel->readBool();
		const bool earlyWakeupEnd = parcel->readBool();
		const uint32_t flags = parcel->readUint32();
		const int64_t desiredPresentTime = parcel->readInt64();
		const bool isAutoTimestamp = parcel->readBool();
		const bool logCallPoints = parcel->readBool();
		@@ -965,9 +961,7 @@ status_t SurfaceComposerClient::Transaction::readFromParcel(const Parcel* parcel

		// Parsing was successful. Update the object.
		mId = transactionId;
		mAnimation = animation;
		mEarlyWakeupStart = earlyWakeupStart;
		mEarlyWakeupEnd = earlyWakeupEnd;
		mFlags = flags;
		mDesiredPresentTime = desiredPresentTime;
		mIsAutoTimestamp = isAutoTimestamp;
		mFrameTimelineInfo = frameTimelineInfo;
		@@ -996,9 +990,7 @@ status_t SurfaceComposerClient::Transaction::writeToParcel(Parcel* parcel) const
		const_cast<SurfaceComposerClient::Transaction*>(this)->cacheBuffers();

		parcel->writeUint64(mId);
		parcel->writeBool(mAnimation);
		parcel->writeBool(mEarlyWakeupStart);
		parcel->writeBool(mEarlyWakeupEnd);
		parcel->writeUint32(mFlags);
		parcel->writeInt64(mDesiredPresentTime);
		parcel->writeBool(mIsAutoTimestamp);
		parcel->writeBool(mLogCallPoints);
		@@ -1131,8 +1123,7 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::merge(Tr
		mInputWindowCommands.merge(other.mInputWindowCommands);

		mMayContainBuffer \|= other.mMayContainBuffer;
		mEarlyWakeupStart = mEarlyWakeupStart \|\| other.mEarlyWakeupStart;
		mEarlyWakeupEnd = mEarlyWakeupEnd \|\| other.mEarlyWakeupEnd;
		mFlags \|= other.mFlags;
		mApplyToken = other.mApplyToken;

		mergeFrameTimelineInfo(mFrameTimelineInfo, other.mFrameTimelineInfo);
		@@ -1154,15 +1145,13 @@ void SurfaceComposerClient::Transaction::clear() {
		mInputWindowCommands.clear();
		mUncacheBuffers.clear();
		mMayContainBuffer = false;
		mAnimation = false;
		mEarlyWakeupStart = false;
		mEarlyWakeupEnd = false;
		mDesiredPresentTime = 0;
		mIsAutoTimestamp = true;
		mFrameTimelineInfo = {};
		mApplyToken = nullptr;
		mMergedTransactionIds.clear();
		mLogCallPoints = false;
		mFlags = 0;
		}

		uint64_t SurfaceComposerClient::Transaction::getId() {
		@@ -1325,7 +1314,6 @@ status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay

		Vector<ComposerState> composerStates;
		Vector<DisplayState> displayStates;
		uint32_t flags = 0;

		for (auto const& kv : mComposerStates) {
		composerStates.add(kv.second);
		@@ -1333,32 +1321,26 @@ status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay

		displayStates = std::move(mDisplayStates);

		if (mAnimation) {
		flags \|= ISurfaceComposer::eAnimation;
		}
		if (oneWay) {
		if (synchronous) {
		ALOGE("Transaction attempted to set synchronous and one way at the same time"
		" this is an invalid request. Synchronous will win for safety");
		} else {
		flags \|= ISurfaceComposer::eOneWay;
		mFlags \|= ISurfaceComposer::eOneWay;
		}
		}

		// If both mEarlyWakeupStart and mEarlyWakeupEnd are set
		// If both ISurfaceComposer::eEarlyWakeupStart and ISurfaceComposer::eEarlyWakeupEnd are set
		// it is equivalent for none
		if (mEarlyWakeupStart && !mEarlyWakeupEnd) {
		flags \|= ISurfaceComposer::eEarlyWakeupStart;
		}
		if (mEarlyWakeupEnd && !mEarlyWakeupStart) {
		flags \|= ISurfaceComposer::eEarlyWakeupEnd;
		uint32_t wakeupFlags = ISurfaceComposer::eEarlyWakeupStart \| ISurfaceComposer::eEarlyWakeupEnd;
		if ((mFlags & wakeupFlags) == wakeupFlags) {
		mFlags &= ~(wakeupFlags);
		}

		sp<IBinder> applyToken = mApplyToken ? mApplyToken : getDefaultApplyToken();

		sp<ISurfaceComposer> sf(ComposerService::getComposerService());
		status_t binderStatus =
		sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags,
		sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, mFlags,
		applyToken, mInputWindowCommands, mDesiredPresentTime,
		mIsAutoTimestamp, mUncacheBuffers, hasListenerCallbacks,
		listenerCallbacks, mId, mMergedTransactionIds);
		@@ -1461,15 +1443,15 @@ std::optional<gui::StalledTransactionInfo> SurfaceComposerClient::getStalledTran
		}

		void SurfaceComposerClient::Transaction::setAnimationTransaction() {
		mAnimation = true;
		mFlags \|= ISurfaceComposer::eAnimation;
		}

		void SurfaceComposerClient::Transaction::setEarlyWakeupStart() {
		mEarlyWakeupStart = true;
		mFlags \|= ISurfaceComposer::eEarlyWakeupStart;
		}

		void SurfaceComposerClient::Transaction::setEarlyWakeupEnd() {
		mEarlyWakeupEnd = true;
		mFlags \|= ISurfaceComposer::eEarlyWakeupEnd;
		}

		layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<SurfaceControl>& sc) {

libs/gui/include/gui/SurfaceComposerClient.h

+1 −4

Original line number	Diff line number	Diff line
		@@ -467,10 +467,7 @@ public:
		std::vector<uint64_t> mMergedTransactionIds;

		uint64_t mId;

		bool mAnimation = false;
		bool mEarlyWakeupStart = false;
		bool mEarlyWakeupEnd = false;
		uint32_t mFlags = 0;

		// Indicates that the Transaction may contain buffers that should be cached. The reason this
		// is only a guess is that buffers can be removed before cache is called. This is only a