Merge changes I77504c05,Ia6afaa31,I176d6962 (858a6a88) · Commits · e / os / platform_frameworks_native

libs/gui/ITransactionCompletedListener.cpp

+18 −2

Original line number	Diff line number	Diff line
		@@ -39,6 +39,12 @@ enum class Tag : uint32_t {

		} // Anonymous namespace

		namespace { // Anonymous

		constexpr int32_t kSerializedCallbackTypeOnCompelteWithJankData = 2;

		} // Anonymous namespace

		status_t FrameEventHistoryStats::writeToParcel(Parcel* output) const {
		status_t err = output->writeUint64(frameNumber);
		if (err != NO_ERROR) return err;
		@@ -349,7 +355,11 @@ ListenerCallbacks ListenerCallbacks::filter(CallbackId::Type type) const {

		status_t CallbackId::writeToParcel(Parcel* output) const {
		SAFE_PARCEL(output->writeInt64, id);
		if (type == Type::ON_COMPLETE && includeJankData) {
		SAFE_PARCEL(output->writeInt32, kSerializedCallbackTypeOnCompelteWithJankData);
		} else {
		SAFE_PARCEL(output->writeInt32, static_cast<int32_t>(type));
		}
		return NO_ERROR;
		}

		@@ -357,7 +367,13 @@ status_t CallbackId::readFromParcel(const Parcel* input) {
		SAFE_PARCEL(input->readInt64, &id);
		int32_t typeAsInt;
		SAFE_PARCEL(input->readInt32, &typeAsInt);
		if (typeAsInt == kSerializedCallbackTypeOnCompelteWithJankData) {
		type = Type::ON_COMPLETE;
		includeJankData = true;
		} else {
		type = static_cast<CallbackId::Type>(typeAsInt);
		includeJankData = false;
		}
		return NO_ERROR;
		}

libs/gui/SurfaceComposerClient.cpp

+31 −7

Original line number	Diff line number	Diff line
		@@ -82,6 +82,8 @@ std::atomic<uint32_t> idCounter = 0;
		int64_t generateId() {
		return (((int64_t)getpid()) << 32) \| ++idCounter;
		}

		void emptyCallback(nsecs_t, const sp<Fence>&, const std::vector<SurfaceControlStats>&) {}
		} // namespace

		ComposerService::ComposerService()
		@@ -249,6 +251,14 @@ CallbackId TransactionCompletedListener::addCallbackFunction(
		surfaceControls,
		CallbackId::Type callbackType) {
		std::lock_guard<std::mutex> lock(mMutex);
		return addCallbackFunctionLocked(callbackFunction, surfaceControls, callbackType);
		}

		CallbackId TransactionCompletedListener::addCallbackFunctionLocked(
		const TransactionCompletedCallback& callbackFunction,
		const std::unordered_set<sp<SurfaceControl>, SurfaceComposerClient::SCHash>&
		surfaceControls,
		CallbackId::Type callbackType) {
		startListeningLocked();

		CallbackId callbackId(getNextIdLocked(), callbackType);
		@@ -257,6 +267,11 @@ CallbackId TransactionCompletedListener::addCallbackFunction(

		for (const auto& surfaceControl : surfaceControls) {
		callbackSurfaceControls[surfaceControl->getHandle()] = surfaceControl;

		if (callbackType == CallbackId::Type::ON_COMPLETE &&
		mJankListeners.count(surfaceControl->getLayerId()) != 0) {
		callbackId.includeJankData = true;
		}
		}

		return callbackId;
		@@ -305,15 +320,26 @@ void TransactionCompletedListener::removeSurfaceStatsListener(void* context, voi
		}

		void TransactionCompletedListener::addSurfaceControlToCallbacks(
		const sp<SurfaceControl>& surfaceControl,
		const std::unordered_set<CallbackId, CallbackIdHash>& callbackIds) {
		SurfaceComposerClient::CallbackInfo& callbackInfo,
		const sp<SurfaceControl>& surfaceControl) {
		std::lock_guard<std::mutex> lock(mMutex);

		for (auto callbackId : callbackIds) {
		bool includingJankData = false;
		for (auto callbackId : callbackInfo.callbackIds) {
		mCallbacks[callbackId].surfaceControls.emplace(std::piecewise_construct,
		std::forward_as_tuple(
		surfaceControl->getHandle()),
		std::forward_as_tuple(surfaceControl));
		includingJankData = includingJankData \|\| callbackId.includeJankData;
		}

		// If no registered callback is requesting jank data, but there is a jank listener registered
		// on the new surface control, add a synthetic callback that requests the jank data.
		if (!includingJankData && mJankListeners.count(surfaceControl->getLayerId()) != 0) {
		CallbackId callbackId =
		addCallbackFunctionLocked(&emptyCallback, callbackInfo.surfaceControls,
		CallbackId::Type::ON_COMPLETE);
		callbackInfo.callbackIds.emplace(callbackId);
		}
		}

		@@ -930,8 +956,7 @@ SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::merge(Tr
		// register all surface controls for all callbackIds for this listener that is merging
		for (const auto& surfaceControl : currentProcessCallbackInfo.surfaceControls) {
		TransactionCompletedListener::getInstance()
		->addSurfaceControlToCallbacks(surfaceControl,
		currentProcessCallbackInfo.callbackIds);
		->addSurfaceControlToCallbacks(currentProcessCallbackInfo, surfaceControl);
		}
		}

		@@ -1267,8 +1292,7 @@ void SurfaceComposerClient::Transaction::registerSurfaceControlForCallback(
		auto& callbackInfo = mListenerCallbacks[TransactionCompletedListener::getIInstance()];
		callbackInfo.surfaceControls.insert(sc);

		TransactionCompletedListener::getInstance()
		->addSurfaceControlToCallbacks(sc, callbackInfo.callbackIds);
		TransactionCompletedListener::getInstance()->addSurfaceControlToCallbacks(callbackInfo, sc);
		}

		SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setPosition(

libs/gui/include/gui/ITransactionCompletedListener.h

+7 −2

Original line number	Diff line number	Diff line
		@@ -40,10 +40,15 @@ class ListenerCallbacks;
		class CallbackId : public Parcelable {
		public:
		int64_t id;
		enum class Type : int32_t { ON_COMPLETE, ON_COMMIT } type;
		enum class Type : int32_t {
		ON_COMPLETE = 0,
		ON_COMMIT = 1,
		/reserved for serialization = 2/
		} type;
		bool includeJankData; // Only respected for ON_COMPLETE callbacks.

		CallbackId() {}
		CallbackId(int64_t id, Type type) : id(id), type(type) {}
		CallbackId(int64_t id, Type type) : id(id), type(type), includeJankData(false) {}
		status_t writeToParcel(Parcel* output) const override;
		status_t readFromParcel(const Parcel* input) override;

libs/gui/include/gui/SurfaceComposerClient.h

+7 −3

Original line number	Diff line number	Diff line
		@@ -878,10 +878,14 @@ public:
		const std::unordered_set<sp<SurfaceControl>, SurfaceComposerClient::SCHash>&
		surfaceControls,
		CallbackId::Type callbackType);
		CallbackId addCallbackFunctionLocked(
		const TransactionCompletedCallback& callbackFunction,
		const std::unordered_set<sp<SurfaceControl>, SurfaceComposerClient::SCHash>&
		surfaceControls,
		CallbackId::Type callbackType) REQUIRES(mMutex);

		void addSurfaceControlToCallbacks(
		const sp<SurfaceControl>& surfaceControl,
		const std::unordered_set<CallbackId, CallbackIdHash>& callbackIds);
		void addSurfaceControlToCallbacks(SurfaceComposerClient::CallbackInfo& callbackInfo,
		const sp<SurfaceControl>& surfaceControl);

		void addQueueStallListener(std::function<void(const std::string&)> stallListener, void* id);
		void removeQueueStallListener(void *id);

services/surfaceflinger/Layer.cpp

+46 −12

Original line number	Diff line number	Diff line
		@@ -734,6 +734,40 @@ bool Layer::isSecure() const {
		return (p != nullptr) ? p->isSecure() : false;
		}

		void Layer::transferAvailableJankData(const std::deque<sp<CallbackHandle>>& handles,
		std::vector<JankData>& jankData) {
		if (mPendingJankClassifications.empty() \|\|
		!mPendingJankClassifications.front()->getJankType()) {
		return;
		}

		bool includeJankData = false;
		for (const auto& handle : handles) {
		for (const auto& cb : handle->callbackIds) {
		if (cb.includeJankData) {
		includeJankData = true;
		break;
		}
		}

		if (includeJankData) {
		jankData.reserve(mPendingJankClassifications.size());
		break;
		}
		}

		while (!mPendingJankClassifications.empty() &&
		mPendingJankClassifications.front()->getJankType()) {
		if (includeJankData) {
		std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame =
		mPendingJankClassifications.front();
		jankData.emplace_back(
		JankData(surfaceFrame->getToken(), surfaceFrame->getJankType().value()));
		}
		mPendingJankClassifications.pop_front();
		}
		}

		// ----------------------------------------------------------------------------
		// transaction
		// ----------------------------------------------------------------------------
		@@ -2798,16 +2832,7 @@ void Layer::releasePendingBuffer(nsecs_t dequeueReadyTime) {
		}

		std::vector<JankData> jankData;
		jankData.reserve(mPendingJankClassifications.size());
		while (!mPendingJankClassifications.empty() &&
		mPendingJankClassifications.front()->getJankType()) {
		std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame =
		mPendingJankClassifications.front();
		mPendingJankClassifications.pop_front();
		jankData.emplace_back(
		JankData(surfaceFrame->getToken(), surfaceFrame->getJankType().value()));
		}

		transferAvailableJankData(mDrawingState.callbackHandles, jankData);
		mFlinger->getTransactionCallbackInvoker().addCallbackHandles(mDrawingState.callbackHandles,
		jankData);
		mDrawingState.callbackHandles = {};
		@@ -3106,6 +3131,7 @@ bool Layer::setTransactionCompletedListeners(const std::vector<sp<CallbackHandle
		return false;
		}

		std::deque<sp<CallbackHandle>> remainingHandles;
		for (const auto& handle : handles) {
		// If this transaction set a buffer on this layer, release its previous buffer
		handle->releasePreviousBuffer = mReleasePreviousBuffer;
		@@ -3120,9 +3146,17 @@ bool Layer::setTransactionCompletedListeners(const std::vector<sp<CallbackHandle
		mDrawingState.callbackHandles.push_back(handle);

		} else { // If this layer will NOT need to be relatched and presented this frame
		// Notify the transaction completed thread this handle is done
		mFlinger->getTransactionCallbackInvoker().registerUnpresentedCallbackHandle(handle);
		// Queue this handle to be notified below.
		remainingHandles.push_back(handle);
		}
		}

		if (!remainingHandles.empty()) {
		// Notify the transaction completed threads these handles are done. These are only the
		// handles that were not added to the mDrawingState, which will be notified later.
		std::vector<JankData> jankData;
		transferAvailableJankData(remainingHandles, jankData);
		mFlinger->getTransactionCallbackInvoker().addCallbackHandles(remainingHandles, jankData);
		}

		mReleasePreviousBuffer = false;