Snap for 9499269 from 70ac5c317c15ed6b623d2bb7c143fb891c5c36c0 to udc-release (982a4c00) · Commits · e / os / android_frameworks_native

libs/binder/include/binder/IInterface.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -230,6 +230,7 @@ constexpr const char* const kManualInterfaces[] = {
		"android.graphicsenv.IGpuService",
		"android.gui.IConsumerListener",
		"android.gui.IGraphicBufferConsumer",
		"android.gui.ITransactionComposerListener",
		"android.gui.SensorEventConnection",
		"android.gui.SensorServer",
		"android.hardware.ICamera",

libs/gui/ISurfaceComposer.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -42,7 +42,6 @@ using namespace aidl::android::hardware::graphics;

		namespace android {

		using gui::CallbackId;
		using gui::DisplayCaptureArgs;
		using gui::IDisplayEventConnection;
		using gui::IRegionSamplingListener;

libs/gui/ITransactionCompletedListener.cpp

+68 −3

Original line number	Diff line number	Diff line
		@@ -21,11 +21,22 @@
		#include <optional>

		#include <gui/ISurfaceComposer.h>
		#include <gui/ITransactionCompletedListener.h>
		#include <gui/LayerState.h>
		#include <gui/ListenerStats.h>
		#include <private/gui/ParcelUtils.h>

		namespace android::gui {
		namespace android {

		namespace { // Anonymous

		enum class Tag : uint32_t {
		ON_TRANSACTION_COMPLETED = IBinder::FIRST_CALL_TRANSACTION,
		ON_RELEASE_BUFFER,
		ON_TRANSACTION_QUEUE_STALLED,
		LAST = ON_TRANSACTION_QUEUE_STALLED,
		};

		} // Anonymous namespace

		status_t FrameEventHistoryStats::writeToParcel(Parcel* output) const {
		status_t err = output->writeUint64(frameNumber);
		@@ -263,6 +274,60 @@ ListenerStats ListenerStats::createEmpty(
		return listenerStats;
		}

		class BpTransactionCompletedListener : public SafeBpInterface<ITransactionCompletedListener> {
		public:
		explicit BpTransactionCompletedListener(const sp<IBinder>& impl)
		: SafeBpInterface<ITransactionCompletedListener>(impl, "BpTransactionCompletedListener") {
		}

		~BpTransactionCompletedListener() override;

		void onTransactionCompleted(ListenerStats stats) override {
		callRemoteAsync<decltype(&ITransactionCompletedListener::
		onTransactionCompleted)>(Tag::ON_TRANSACTION_COMPLETED,
		stats);
		}

		void onReleaseBuffer(ReleaseCallbackId callbackId, sp<Fence> releaseFence,
		uint32_t currentMaxAcquiredBufferCount) override {
		callRemoteAsync<decltype(&ITransactionCompletedListener::
		onReleaseBuffer)>(Tag::ON_RELEASE_BUFFER, callbackId,
		releaseFence,
		currentMaxAcquiredBufferCount);
		}

		void onTransactionQueueStalled(const String8& reason) override {
		callRemoteAsync<
		decltype(&ITransactionCompletedListener::
		onTransactionQueueStalled)>(Tag::ON_TRANSACTION_QUEUE_STALLED,
		reason);
		}
		};

		// Out-of-line virtual method definitions to trigger vtable emission in this translation unit (see
		// clang warning -Wweak-vtables)
		BpTransactionCompletedListener::~BpTransactionCompletedListener() = default;

		IMPLEMENT_META_INTERFACE(TransactionCompletedListener, "android.gui.ITransactionComposerListener");

		status_t BnTransactionCompletedListener::onTransact(uint32_t code, const Parcel& data,
		Parcel* reply, uint32_t flags) {
		if (code < IBinder::FIRST_CALL_TRANSACTION \|\| code > static_cast<uint32_t>(Tag::LAST)) {
		return BBinder::onTransact(code, data, reply, flags);
		}
		auto tag = static_cast<Tag>(code);
		switch (tag) {
		case Tag::ON_TRANSACTION_COMPLETED:
		return callLocalAsync(data, reply,
		&ITransactionCompletedListener::onTransactionCompleted);
		case Tag::ON_RELEASE_BUFFER:
		return callLocalAsync(data, reply, &ITransactionCompletedListener::onReleaseBuffer);
		case Tag::ON_TRANSACTION_QUEUE_STALLED:
		return callLocalAsync(data, reply,
		&ITransactionCompletedListener::onTransactionQueueStalled);
		}
		}

		ListenerCallbacks ListenerCallbacks::filter(CallbackId::Type type) const {
		std::vector<CallbackId> filteredCallbackIds;
		for (const auto& callbackId : callbackIds) {
		@@ -301,4 +366,4 @@ status_t ReleaseCallbackId::readFromParcel(const Parcel* input) {

		const ReleaseCallbackId ReleaseCallbackId::INVALID_ID = ReleaseCallbackId(0, 0);

		}; // namespace android::gui
		}; // namespace android

libs/gui/LayerState.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -51,7 +51,6 @@

		namespace android {

		using gui::CallbackId;
		using gui::FocusRequest;
		using gui::WindowInfoHandle;

libs/gui/SurfaceComposerClient.cpp

+23 −24

Original line number	Diff line number	Diff line
		@@ -314,8 +314,7 @@ void TransactionCompletedListener::addSurfaceControlToCallbacks(
		}
		}

		binder::Status TransactionCompletedListener::onTransactionCompleted(
		const ListenerStats& listenerStats) {
		void TransactionCompletedListener::onTransactionCompleted(ListenerStats listenerStats) {
		std::unordered_map<CallbackId, CallbackTranslation, CallbackIdHash> callbacksMap;
		std::multimap<int32_t, sp<JankDataListener>> jankListenersMap;
		{
		@@ -455,10 +454,9 @@ binder::Status TransactionCompletedListener::onTransactionCompleted(
		}
		}
		}
		return binder::Status::ok();
		}

		binder::Status TransactionCompletedListener::onTransactionQueueStalled(const std::string& reason) {
		void TransactionCompletedListener::onTransactionQueueStalled(const String8& reason) {
		std::unordered_map<void*, std::function<void(const std::string&)>> callbackCopy;
		{
		std::scoped_lock<std::mutex> lock(mMutex);
		@@ -467,7 +465,6 @@ binder::Status TransactionCompletedListener::onTransactionQueueStalled(const std
		for (auto const& it : callbackCopy) {
		it.second(reason.c_str());
		}
		return binder::Status::ok();
		}

		void TransactionCompletedListener::addQueueStallListener(
		@@ -481,12 +478,9 @@ void TransactionCompletedListener::removeQueueStallListener(void* id) {
		mQueueStallListeners.erase(id);
		}

		binder::Status TransactionCompletedListener::onReleaseBuffer(
		const ReleaseCallbackId& callbackId,
		const std::optional<os::ParcelFileDescriptor>& releaseFenceFd,
		int32_t currentMaxAcquiredBufferCount) {
		sp<Fence> releaseFence(releaseFenceFd ? new Fence(::dup(releaseFenceFd->get()))
		: Fence::NO_FENCE);
		void TransactionCompletedListener::onReleaseBuffer(ReleaseCallbackId callbackId,
		sp<Fence> releaseFence,
		uint32_t currentMaxAcquiredBufferCount) {
		ReleaseBufferCallback callback;
		{
		std::scoped_lock<std::mutex> lock(mMutex);
		@@ -495,14 +489,13 @@ binder::Status TransactionCompletedListener::onReleaseBuffer(
		if (!callback) {
		ALOGE("Could not call release buffer callback, buffer not found %s",
		callbackId.to_string().c_str());
		return binder::Status::fromExceptionCode(binder::Status::EX_ILLEGAL_ARGUMENT);
		return;
		}
		std::optional<uint32_t> optionalMaxAcquiredBufferCount =
		static_cast<uint32_t>(currentMaxAcquiredBufferCount) == UINT_MAX
		currentMaxAcquiredBufferCount == UINT_MAX
		? std::nullopt
		: std::make_optional<uint32_t>(currentMaxAcquiredBufferCount);
		callback(callbackId, releaseFence, optionalMaxAcquiredBufferCount);
		return binder::Status::ok();
		}

		ReleaseBufferCallback TransactionCompletedListener::popReleaseBufferCallbackLocked(
		@@ -832,11 +825,7 @@ void SurfaceComposerClient::Transaction::releaseBufferIfOverwriting(const layer_
		->mReleaseCallbackThread
		.addReleaseCallback(state.bufferData->generateReleaseCallbackId(), fence);
		} else {
		std::optional<os::ParcelFileDescriptor> fenceFd;
		if (fence != Fence::NO_FENCE) {
		fenceFd = os::ParcelFileDescriptor(base::unique_fd(::dup(fence->get())));
		}
		listener->onReleaseBuffer(state.bufferData->generateReleaseCallbackId(), fenceFd, UINT_MAX);
		listener->onReleaseBuffer(state.bufferData->generateReleaseCallbackId(), fence, UINT_MAX);
		}
		}

		@@ -2496,6 +2485,20 @@ status_t SurfaceComposerClient::clearBootDisplayMode(const sp<IBinder>& display)
		return statusTFromBinderStatus(status);
		}

		status_t SurfaceComposerClient::getHdrConversionCapabilities(
		std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) {
		binder::Status status = ComposerServiceAIDL::getComposerService()->getHdrConversionCapabilities(
		hdrConversionCapabilities);
		return statusTFromBinderStatus(status);
		}

		status_t SurfaceComposerClient::setHdrConversionStrategy(
		gui::HdrConversionStrategy hdrConversionStrategy) {
		binder::Status status = ComposerServiceAIDL::getComposerService()->setHdrConversionStrategy(
		hdrConversionStrategy);
		return statusTFromBinderStatus(status);
		}

		status_t SurfaceComposerClient::setOverrideFrameRate(uid_t uid, float frameRate) {
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->setOverrideFrameRate(uid, frameRate);
		@@ -2866,11 +2869,7 @@ void ReleaseCallbackThread::threadMain() {

		while (!callbackInfos.empty()) {
		auto [callbackId, releaseFence] = callbackInfos.front();
		std::optional<os::ParcelFileDescriptor> fenceFd;
		if (releaseFence != Fence::NO_FENCE) {
		fenceFd = os::ParcelFileDescriptor(base::unique_fd(::dup(releaseFence->get())));
		}
		listener->onReleaseBuffer(callbackId, fenceFd, UINT_MAX);
		listener->onReleaseBuffer(callbackId, std::move(releaseFence), UINT_MAX);
		callbackInfos.pop();
		}