libs/gui/TransactionState.cpp - platform/frameworks/native - Git at Google

 /*
  * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "TransactionState"
 #include <gui/LayerState.h>
 #include <gui/SurfaceComposerClient.h>
 #include <gui/TransactionState.h>
 #include <private/gui/ParcelUtils.h>
 #include <algorithm>
 #include <numeric>

 namespace android {

 void TransactionListenerCallbacks::clear() {
     *this = TransactionListenerCallbacks();
 }

 status_t TransactionListenerCallbacks::writeToParcel(Parcel* parcel) const {
     SAFE_PARCEL(parcel->writeBool, mHasListenerCallbacks);
     SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mFlattenedListenerCallbacks.size()));
     for (const auto& [listener, callbackIds] : mFlattenedListenerCallbacks) {
         SAFE_PARCEL(parcel->writeStrongBinder, listener);
         SAFE_PARCEL(parcel->writeParcelableVector, callbackIds);
     }

     return NO_ERROR;
 }

 status_t TransactionListenerCallbacks::readFromParcel(const Parcel* parcel) {
     SAFE_PARCEL(parcel->readBool, &mHasListenerCallbacks);
     uint32_t count;
     SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
     mFlattenedListenerCallbacks.clear();
     mFlattenedListenerCallbacks.reserve(count);
     for (uint32_t i = 0; i < count; i++) {
         sp<IBinder> tmpBinder;
         SAFE_PARCEL(parcel->readStrongBinder, &tmpBinder);
         std::vector<CallbackId> callbackIds;
         SAFE_PARCEL(parcel->readParcelableVector, &callbackIds);
         mFlattenedListenerCallbacks.emplace_back(tmpBinder, callbackIds);
     }

     return NO_ERROR;
 }

 status_t TransactionState::writeToParcel(Parcel* parcel) const {
     SAFE_PARCEL(parcel->writeUint64, mId);
     SAFE_PARCEL(parcel->writeUint32, mFlags);
     SAFE_PARCEL(parcel->writeInt64, mDesiredPresentTime);
     SAFE_PARCEL(parcel->writeBool, mIsAutoTimestamp);

     SAFE_PARCEL(parcel->writeParcelable, mFrameTimelineInfo);

     SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mUncacheBuffers.size()));
     for (const client_cache_t& uncacheBuffer : mUncacheBuffers) {
         SAFE_PARCEL(parcel->writeStrongBinder, uncacheBuffer.token.promote());
         SAFE_PARCEL(parcel->writeUint64, uncacheBuffer.id);
     }

     SAFE_PARCEL(parcel->writeUint64Vector, mMergedTransactionIds);
     SAFE_PARCEL(mCallbacks.writeToParcel, parcel);
     SAFE_PARCEL(mInputWindowCommands.write, *parcel);
     SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mEarlyWakeupInfos.size()));
     for (const auto& e : mEarlyWakeupInfos) {
         e.writeToParcel(parcel);
     }
     SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mComposerStates.size()));
     for (const auto& s : mComposerStates) {
         SAFE_PARCEL(s.write, *parcel);
     }

     SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mDisplayStates.size()));
     for (const auto& d : mDisplayStates) {
         SAFE_PARCEL(d.write, *parcel);
     }

     SAFE_PARCEL(parcel->writeParcelableVector, mBarriers);

     return NO_ERROR;
 }

 status_t TransactionState::readFromParcel(const Parcel* parcel) {
     SAFE_PARCEL(parcel->readUint64, &mId);
     SAFE_PARCEL(parcel->readUint32, &mFlags);
     SAFE_PARCEL(parcel->readInt64, &mDesiredPresentTime);
     SAFE_PARCEL(parcel->readBool, &mIsAutoTimestamp);

     SAFE_PARCEL(parcel->readParcelable, &mFrameTimelineInfo);

     uint32_t count;
     SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize())
     mUncacheBuffers.clear();
     mUncacheBuffers.reserve(count);
     for (size_t i = 0; i < count; i++) {
         client_cache_t client_cache;
         sp<IBinder> tmpBinder;
         SAFE_PARCEL(parcel->readStrongBinder, &tmpBinder);
         client_cache.token = tmpBinder;
         SAFE_PARCEL(parcel->readUint64, &client_cache.id);
         mUncacheBuffers.emplace_back(std::move(client_cache));
     }

     SAFE_PARCEL(parcel->readUint64Vector, &mMergedTransactionIds);
     SAFE_PARCEL(mCallbacks.readFromParcel, parcel);
     SAFE_PARCEL(mInputWindowCommands.read, *parcel);
     count = 0;
     SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
     std::vector<gui::EarlyWakeupInfo> earlyWakeupInfos;
     earlyWakeupInfos.reserve(count);
     for (size_t i = 0; i < count; i++) {
         gui::EarlyWakeupInfo e;
         e.readFromParcel(parcel);
         earlyWakeupInfos.push_back(std::move(e));
     }
     mEarlyWakeupInfos = std::move(earlyWakeupInfos);

     SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
     mComposerStates.clear();
     mComposerStates.reserve(count);
     for (size_t i = 0; i < count; i++) {
         ComposerState s;
         SAFE_PARCEL(s.read, *parcel);
         mComposerStates.emplace_back(std::move(s));
     }

     SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
     mDisplayStates.clear();
     mDisplayStates.reserve(count);
     for (size_t i = 0; i < count; i++) {
         DisplayState d;
         SAFE_PARCEL(d.read, *parcel);
         mDisplayStates.emplace_back(std::move(d));
     }

     mBarriers.clear();
     SAFE_PARCEL(parcel->readParcelableVector, &mBarriers);
     return NO_ERROR;
 }

 void TransactionState::merge(TransactionState&& other,
                              const std::function<void(const layer_state_t&)>& onBufferOverwrite) {
     // TODO(b/385156191) Consider merging desired present time.
     mFlags |= other.mFlags;
     while (mMergedTransactionIds.size() + other.mMergedTransactionIds.size() >
                    MAX_MERGE_HISTORY_LENGTH - 1 &&
            mMergedTransactionIds.size() > 0) {
         mMergedTransactionIds.pop_back();
     }
     if (other.mMergedTransactionIds.size() == MAX_MERGE_HISTORY_LENGTH) {
         mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
                                      other.mMergedTransactionIds.begin(),
                                      other.mMergedTransactionIds.end() - 1);
     } else if (other.mMergedTransactionIds.size() > 0u) {
         mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
                                      other.mMergedTransactionIds.begin(),
                                      other.mMergedTransactionIds.end());
     }

     for (auto& cacheId : other.mUncacheBuffers) {
         mUncacheBuffers.emplace_back(std::move(cacheId));
     }

     mergeFrameTimelineInfo(other.mFrameTimelineInfo);

     mInputWindowCommands.merge(other.mInputWindowCommands);

     for (gui::EarlyWakeupInfo& op : other.mEarlyWakeupInfos) {
         mEarlyWakeupInfos.emplace_back(std::move(op));
     }

     for (auto& otherState : other.mComposerStates) {
         if (auto it = std::find_if(mComposerStates.begin(), mComposerStates.end(),
                                    [&otherState](const auto& composerState) {
                                        return composerState.state.surface ==
                                                otherState.state.surface;
                                    });
             it != mComposerStates.end()) {
             if (otherState.state.what & layer_state_t::eBufferChanged) {
                 onBufferOverwrite(it->state);
             }
             it->state.merge(otherState.state);
         } else {
             mComposerStates.emplace_back(std::move(otherState));
         }
     }

     for (auto& state : other.mDisplayStates) {
         if (auto it = std::find_if(mDisplayStates.begin(), mDisplayStates.end(),
                                    [&state](const auto& displayState) {
                                        return displayState.token == state.token;
                                    });
             it != mDisplayStates.end()) {
             it->merge(state);
         } else {
             mDisplayStates.emplace_back(std::move(state));
         }
     }

     mMergedTransactionIds.insert(mMergedTransactionIds.begin(), other.mId);

     mBarriers.insert(mBarriers.end(), std::make_move_iterator(other.mBarriers.begin()),
                      std::make_move_iterator(other.mBarriers.end()));
     if (mBarriers.size() > MAX_BARRIERS_LENGTH) {
         int numToRemove = mBarriers.size() - MAX_BARRIERS_LENGTH;
         std::string droppedBarriers =
                 std::accumulate(mBarriers.begin(), mBarriers.begin() + numToRemove, std::string(),
                                 [](std::string&& s,
                                    const gui::TransactionBarrier& barrier) -> std::string {
                                     s += barrier.toString() + ",";
                                     return s;
                                 });
         ALOGE("Dropping %d transaction barriers: %s", numToRemove, droppedBarriers.c_str());
         mBarriers.erase(mBarriers.begin(), mBarriers.begin() + numToRemove);
     }

     other.clear();
 }

 // copied from FrameTimelineInfo::merge()
 void TransactionState::mergeFrameTimelineInfo(const FrameTimelineInfo& other) {
     // When merging vsync Ids we take the oldest valid one
     if (mFrameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID &&
         other.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
         if (other.vsyncId > mFrameTimelineInfo.vsyncId) {
             mFrameTimelineInfo = other;
         }
     } else if (mFrameTimelineInfo.vsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {
         mFrameTimelineInfo = other;
     }
 }

 void TransactionState::clear() {
     mId = 0;
     mFlags = 0;
     mDesiredPresentTime = 0;
     mIsAutoTimestamp = true;
     mCallbacks.clear();
     mUncacheBuffers.clear();
     mFrameTimelineInfo = {};
     mMergedTransactionIds.clear();
     mInputWindowCommands.clear();
     mEarlyWakeupInfos.clear();
     mComposerStates.clear();
     mDisplayStates.clear();
     mBarriers.clear();
 }

 layer_state_t* TransactionState::getLayerState(const sp<SurfaceControl>& sc) {
     auto handle = sc->getLayerStateHandle();
     if (auto it = std::find_if(mComposerStates.begin(), mComposerStates.end(),
                                [&handle](const auto& composerState) {
                                    return composerState.state.surface == handle;
                                });
         it != mComposerStates.end()) {
         return &it->state;
     }

     // we don't have it, add an initialized layer_state to our list
     ComposerState s;
     s.state.surface = handle;
     s.state.layerId = sc->getLayerId();
     mComposerStates.emplace_back(std::move(s));

     return &mComposerStates.back().state;
 }

 DisplayState& TransactionState::getDisplayState(const sp<IBinder>& token) {
     if (auto it = std::find_if(mDisplayStates.begin(), mDisplayStates.end(),
                                [token](const auto& display) { return display.token == token; });
         it != mDisplayStates.end()) {
         return *it;
     }

     // If display state doesn't exist, add a new one.
     DisplayState s;
     s.token = token;
     mDisplayStates.emplace_back(std::move(s));
     return mDisplayStates.back();
 }

 }; // namespace android
	/*
	* Copyright (C) 2025 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "TransactionState"
	#include <gui/LayerState.h>
	#include <gui/SurfaceComposerClient.h>
	#include <gui/TransactionState.h>
	#include <private/gui/ParcelUtils.h>
	#include <algorithm>
	#include <numeric>

	namespace android {

	void TransactionListenerCallbacks::clear() {
	*this = TransactionListenerCallbacks();
	}

	status_t TransactionListenerCallbacks::writeToParcel(Parcel* parcel) const {
	SAFE_PARCEL(parcel->writeBool, mHasListenerCallbacks);
	SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mFlattenedListenerCallbacks.size()));
	for (const auto& [listener, callbackIds] : mFlattenedListenerCallbacks) {
	SAFE_PARCEL(parcel->writeStrongBinder, listener);
	SAFE_PARCEL(parcel->writeParcelableVector, callbackIds);
	}

	return NO_ERROR;
	}

	status_t TransactionListenerCallbacks::readFromParcel(const Parcel* parcel) {
	SAFE_PARCEL(parcel->readBool, &mHasListenerCallbacks);
	uint32_t count;
	SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
	mFlattenedListenerCallbacks.clear();
	mFlattenedListenerCallbacks.reserve(count);
	for (uint32_t i = 0; i < count; i++) {
	sp<IBinder> tmpBinder;
	SAFE_PARCEL(parcel->readStrongBinder, &tmpBinder);
	std::vector<CallbackId> callbackIds;
	SAFE_PARCEL(parcel->readParcelableVector, &callbackIds);
	mFlattenedListenerCallbacks.emplace_back(tmpBinder, callbackIds);
	}

	return NO_ERROR;
	}

	status_t TransactionState::writeToParcel(Parcel* parcel) const {
	SAFE_PARCEL(parcel->writeUint64, mId);
	SAFE_PARCEL(parcel->writeUint32, mFlags);
	SAFE_PARCEL(parcel->writeInt64, mDesiredPresentTime);
	SAFE_PARCEL(parcel->writeBool, mIsAutoTimestamp);

	SAFE_PARCEL(parcel->writeParcelable, mFrameTimelineInfo);

	SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mUncacheBuffers.size()));
	for (const client_cache_t& uncacheBuffer : mUncacheBuffers) {
	SAFE_PARCEL(parcel->writeStrongBinder, uncacheBuffer.token.promote());
	SAFE_PARCEL(parcel->writeUint64, uncacheBuffer.id);
	}

	SAFE_PARCEL(parcel->writeUint64Vector, mMergedTransactionIds);
	SAFE_PARCEL(mCallbacks.writeToParcel, parcel);
	SAFE_PARCEL(mInputWindowCommands.write, *parcel);
	SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mEarlyWakeupInfos.size()));
	for (const auto& e : mEarlyWakeupInfos) {
	e.writeToParcel(parcel);
	}
	SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mComposerStates.size()));
	for (const auto& s : mComposerStates) {
	SAFE_PARCEL(s.write, *parcel);
	}

	SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mDisplayStates.size()));
	for (const auto& d : mDisplayStates) {
	SAFE_PARCEL(d.write, *parcel);
	}

	SAFE_PARCEL(parcel->writeParcelableVector, mBarriers);

	return NO_ERROR;
	}

	status_t TransactionState::readFromParcel(const Parcel* parcel) {
	SAFE_PARCEL(parcel->readUint64, &mId);
	SAFE_PARCEL(parcel->readUint32, &mFlags);
	SAFE_PARCEL(parcel->readInt64, &mDesiredPresentTime);
	SAFE_PARCEL(parcel->readBool, &mIsAutoTimestamp);

	SAFE_PARCEL(parcel->readParcelable, &mFrameTimelineInfo);

	uint32_t count;
	SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize())
	mUncacheBuffers.clear();
	mUncacheBuffers.reserve(count);
	for (size_t i = 0; i < count; i++) {
	client_cache_t client_cache;
	sp<IBinder> tmpBinder;
	SAFE_PARCEL(parcel->readStrongBinder, &tmpBinder);
	client_cache.token = tmpBinder;
	SAFE_PARCEL(parcel->readUint64, &client_cache.id);
	mUncacheBuffers.emplace_back(std::move(client_cache));
	}

	SAFE_PARCEL(parcel->readUint64Vector, &mMergedTransactionIds);
	SAFE_PARCEL(mCallbacks.readFromParcel, parcel);
	SAFE_PARCEL(mInputWindowCommands.read, *parcel);
	count = 0;
	SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
	std::vector<gui::EarlyWakeupInfo> earlyWakeupInfos;
	earlyWakeupInfos.reserve(count);
	for (size_t i = 0; i < count; i++) {
	gui::EarlyWakeupInfo e;
	e.readFromParcel(parcel);
	earlyWakeupInfos.push_back(std::move(e));
	}
	mEarlyWakeupInfos = std::move(earlyWakeupInfos);

	SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
	mComposerStates.clear();
	mComposerStates.reserve(count);
	for (size_t i = 0; i < count; i++) {
	ComposerState s;
	SAFE_PARCEL(s.read, *parcel);
	mComposerStates.emplace_back(std::move(s));
	}

	SAFE_PARCEL_READ_SIZE(parcel->readUint32, &count, parcel->dataSize());
	mDisplayStates.clear();
	mDisplayStates.reserve(count);
	for (size_t i = 0; i < count; i++) {
	DisplayState d;
	SAFE_PARCEL(d.read, *parcel);
	mDisplayStates.emplace_back(std::move(d));
	}

	mBarriers.clear();
	SAFE_PARCEL(parcel->readParcelableVector, &mBarriers);
	return NO_ERROR;
	}

	void TransactionState::merge(TransactionState&& other,
	const std::function<void(const layer_state_t&)>& onBufferOverwrite) {
	// TODO(b/385156191) Consider merging desired present time.
	mFlags \|= other.mFlags;
	while (mMergedTransactionIds.size() + other.mMergedTransactionIds.size() >
	MAX_MERGE_HISTORY_LENGTH - 1 &&
	mMergedTransactionIds.size() > 0) {
	mMergedTransactionIds.pop_back();
	}
	if (other.mMergedTransactionIds.size() == MAX_MERGE_HISTORY_LENGTH) {
	mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
	other.mMergedTransactionIds.begin(),
	other.mMergedTransactionIds.end() - 1);
	} else if (other.mMergedTransactionIds.size() > 0u) {
	mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
	other.mMergedTransactionIds.begin(),
	other.mMergedTransactionIds.end());
	}

	for (auto& cacheId : other.mUncacheBuffers) {
	mUncacheBuffers.emplace_back(std::move(cacheId));
	}

	mergeFrameTimelineInfo(other.mFrameTimelineInfo);

	mInputWindowCommands.merge(other.mInputWindowCommands);

	for (gui::EarlyWakeupInfo& op : other.mEarlyWakeupInfos) {
	mEarlyWakeupInfos.emplace_back(std::move(op));
	}

	for (auto& otherState : other.mComposerStates) {
	if (auto it = std::find_if(mComposerStates.begin(), mComposerStates.end(),
	[&otherState](const auto& composerState) {
	return composerState.state.surface ==
	otherState.state.surface;
	});
	it != mComposerStates.end()) {
	if (otherState.state.what & layer_state_t::eBufferChanged) {
	onBufferOverwrite(it->state);
	}
	it->state.merge(otherState.state);
	} else {
	mComposerStates.emplace_back(std::move(otherState));
	}
	}

	for (auto& state : other.mDisplayStates) {
	if (auto it = std::find_if(mDisplayStates.begin(), mDisplayStates.end(),
	[&state](const auto& displayState) {
	return displayState.token == state.token;
	});
	it != mDisplayStates.end()) {
	it->merge(state);
	} else {
	mDisplayStates.emplace_back(std::move(state));
	}
	}

	mMergedTransactionIds.insert(mMergedTransactionIds.begin(), other.mId);

	mBarriers.insert(mBarriers.end(), std::make_move_iterator(other.mBarriers.begin()),
	std::make_move_iterator(other.mBarriers.end()));
	if (mBarriers.size() > MAX_BARRIERS_LENGTH) {
	int numToRemove = mBarriers.size() - MAX_BARRIERS_LENGTH;
	std::string droppedBarriers =
	std::accumulate(mBarriers.begin(), mBarriers.begin() + numToRemove, std::string(),
	[](std::string&& s,
	const gui::TransactionBarrier& barrier) -> std::string {
	s += barrier.toString() + ",";
	return s;
	});
	ALOGE("Dropping %d transaction barriers: %s", numToRemove, droppedBarriers.c_str());
	mBarriers.erase(mBarriers.begin(), mBarriers.begin() + numToRemove);
	}

	other.clear();
	}

	// copied from FrameTimelineInfo::merge()
	void TransactionState::mergeFrameTimelineInfo(const FrameTimelineInfo& other) {
	// When merging vsync Ids we take the oldest valid one
	if (mFrameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID &&
	other.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
	if (other.vsyncId > mFrameTimelineInfo.vsyncId) {
	mFrameTimelineInfo = other;
	}
	} else if (mFrameTimelineInfo.vsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {
	mFrameTimelineInfo = other;
	}
	}

	void TransactionState::clear() {
	mId = 0;
	mFlags = 0;
	mDesiredPresentTime = 0;
	mIsAutoTimestamp = true;
	mCallbacks.clear();
	mUncacheBuffers.clear();
	mFrameTimelineInfo = {};
	mMergedTransactionIds.clear();
	mInputWindowCommands.clear();
	mEarlyWakeupInfos.clear();
	mComposerStates.clear();
	mDisplayStates.clear();
	mBarriers.clear();
	}

	layer_state_t* TransactionState::getLayerState(const sp<SurfaceControl>& sc) {
	auto handle = sc->getLayerStateHandle();
	if (auto it = std::find_if(mComposerStates.begin(), mComposerStates.end(),
	[&handle](const auto& composerState) {
	return composerState.state.surface == handle;
	});
	it != mComposerStates.end()) {
	return &it->state;
	}

	// we don't have it, add an initialized layer_state to our list
	ComposerState s;
	s.state.surface = handle;
	s.state.layerId = sc->getLayerId();
	mComposerStates.emplace_back(std::move(s));

	return &mComposerStates.back().state;
	}

	DisplayState& TransactionState::getDisplayState(const sp<IBinder>& token) {
	if (auto it = std::find_if(mDisplayStates.begin(), mDisplayStates.end(),
	[token](const auto& display) { return display.token == token; });
	it != mDisplayStates.end()) {
	return *it;
	}

	// If display state doesn't exist, add a new one.
	DisplayState s;
	s.token = token;
	mDisplayStates.emplace_back(std::move(s));
	return mDisplayStates.back();
	}

	}; // namespace android