blob: 74097b8fd4be1b533d6c8c328bbcec73fcd7c10a [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "SurfaceComposerClient"
18
Vishnu Nair9402bb02022-09-28 16:45:06 -070019#include <semaphore.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020#include <stdint.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <sys/types.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080022
Marzia Favaroc9918bf2024-07-10 14:45:35 +000023#include <com_android_graphics_libgui_flags.h>
24
Patrick Williams641f7f22022-06-22 19:25:35 +000025#include <android/gui/BnWindowInfosReportedListener.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080026#include <android/gui/DisplayState.h>
Marzia Favarodcc9d9b2024-01-10 10:17:00 +000027#include <android/gui/EdgeExtensionParameters.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080028#include <android/gui/ISurfaceComposerClient.h>
chaviw60c9d3e2021-06-04 12:52:17 -050029#include <android/gui/IWindowInfosListener.h>
Chavi Weingarten076acac2023-01-19 17:20:43 +000030#include <android/gui/TrustedPresentationThresholds.h>
Huihong Luo3bdef862022-03-03 11:57:19 -080031#include <android/os/IInputConstants.h>
Sally Qi0abc4a52024-09-26 16:13:06 -070032#include <gui/DisplayLuts.h>
Ady Abraham6cdd3fd2023-09-07 18:45:58 -070033#include <gui/FrameRateUtils.h>
Patrick Williams640b7292022-10-11 19:25:06 +000034#include <gui/TraceUtils.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035#include <utils/Errors.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080036#include <utils/Log.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070037#include <utils/SortedVector.h>
38#include <utils/String8.h>
39#include <utils/threads.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080040
Marissa Wall7a9b6ff2018-08-21 17:26:20 -070041#include <binder/IPCThreadState.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070042#include <binder/IServiceManager.h>
Marissa Wall7a9b6ff2018-08-21 17:26:20 -070043#include <binder/ProcessState.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080044
Michael Wright28f24d02016-07-12 13:30:53 -070045#include <system/graphics.h>
46
Alec Mouri924f9502024-08-15 20:01:08 +000047#include <gui/AidlUtil.h>
Robert Carr673134e2017-01-09 19:48:38 -080048#include <gui/BufferItemConsumer.h>
Mathias Agopianabe815d2013-03-19 22:22:21 -070049#include <gui/CpuConsumer.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080050#include <gui/IGraphicBufferProducer.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080051#include <gui/ISurfaceComposer.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070052#include <gui/LayerState.h>
Robert Carr0d480722017-01-10 16:42:54 -080053#include <gui/Surface.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080054#include <gui/SurfaceComposerClient.h>
chaviw98318de2021-05-19 16:45:23 -050055#include <gui/WindowInfo.h>
Marin Shalamanov3b1f7bc2021-03-16 15:51:53 +010056#include <private/gui/ParcelUtils.h>
Marin Shalamanova7fe3042021-01-29 21:02:08 +010057#include <ui/DisplayMode.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080058#include <ui/DisplayState.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010059#include <ui/DynamicDisplayInfo.h>
ramindani8204da22024-10-18 15:22:52 -070060#include <ui/FrameRateCategoryRate.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061
Chavi Weingartene0237bb2023-02-06 21:48:32 +000062#include <android-base/thread_annotations.h>
Chavi Weingartenc78f53c2023-04-14 18:50:53 +000063#include <gui/LayerStatePermissions.h>
Chavi Weingartenf6fb4452024-01-23 21:10:30 +000064#include <gui/ScreenCaptureResults.h>
Mathias Agopian41f673c2011-11-17 17:48:35 -080065#include <private/gui/ComposerService.h>
Huihong Luof5029222021-12-16 14:33:46 -080066#include <private/gui/ComposerServiceAIDL.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067
Marissa Wall73411622019-01-25 10:45:41 -080068// This server size should always be smaller than the server cache size
Patrick Williams271afa92023-08-09 18:30:22 -050069#define BUFFER_CACHE_MAX_SIZE 4096
Marissa Wall73411622019-01-25 10:45:41 -080070
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071namespace android {
Peiyong Lin9f034472018-03-28 15:29:00 -070072
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -050073using aidl::android::hardware::graphics::common::DisplayDecorationSupport;
chaviw98318de2021-05-19 16:45:23 -050074using gui::FocusRequest;
Huihong Luoecc1f902021-11-20 11:55:05 -080075using gui::IRegionSamplingListener;
Chavi Weingarten076acac2023-01-19 17:20:43 +000076using gui::TrustedPresentationThresholds;
chaviw98318de2021-05-19 16:45:23 -050077using gui::WindowInfo;
78using gui::WindowInfoHandle;
chaviw60c9d3e2021-06-04 12:52:17 -050079using gui::WindowInfosListener;
Huihong Luo3bdef862022-03-03 11:57:19 -080080using gui::aidl_utils::statusTFromBinderStatus;
Peiyong Lin9f034472018-03-28 15:29:00 -070081using ui::ColorMode;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082// ---------------------------------------------------------------------------
83
Mathias Agopian7e27f052010-05-28 14:22:23 -070084ANDROID_SINGLETON_STATIC_INSTANCE(ComposerService);
Huihong Luof5029222021-12-16 14:33:46 -080085ANDROID_SINGLETON_STATIC_INSTANCE(ComposerServiceAIDL);
Mathias Agopian7e27f052010-05-28 14:22:23 -070086
Vishnu Nairab6dc5c2021-12-09 08:39:57 -080087namespace {
88// Initialize transaction id counter used to generate transaction ids
89std::atomic<uint32_t> idCounter = 0;
90int64_t generateId() {
91 return (((int64_t)getpid()) << 32) | ++idCounter;
92}
Pascal Muetschard29247e52022-11-08 11:33:10 +010093
Pascal Mütschardd56514e2024-05-24 17:37:13 +020094constexpr int64_t INVALID_VSYNC = -1;
95
Vishnu Nairab6dc5c2021-12-09 08:39:57 -080096} // namespace
97
Alan Dingfc6eab52024-05-02 18:28:45 -070098const std::string SurfaceComposerClient::kEmpty{};
99
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700100ComposerService::ComposerService()
101: Singleton<ComposerService>() {
Andy McFadden6652b3e2012-09-06 18:45:56 -0700102 Mutex::Autolock _l(mLock);
103 connectLocked();
104}
105
Brian Lindahl9b85a192021-05-10 09:56:33 +0000106bool ComposerService::connectLocked() {
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700107 const String16 name("SurfaceFlinger");
Brian Lindahl9b85a192021-05-10 09:56:33 +0000108 mComposerService = waitForService<ISurfaceComposer>(name);
109 if (mComposerService == nullptr) {
110 return false; // fatal error or permission problem
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700111 }
Andy McFadden6652b3e2012-09-06 18:45:56 -0700112
113 // Create the death listener.
114 class DeathObserver : public IBinder::DeathRecipient {
115 ComposerService& mComposerService;
116 virtual void binderDied(const wp<IBinder>& who) {
117 ALOGW("ComposerService remote (surfaceflinger) died [%p]",
118 who.unsafe_get());
119 mComposerService.composerServiceDied();
120 }
121 public:
Chih-Hung Hsiehe2347b72016-04-25 15:41:05 -0700122 explicit DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
Andy McFadden6652b3e2012-09-06 18:45:56 -0700123 };
124
125 mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));
Marco Nelissen2ea926b2014-11-14 08:01:01 -0800126 IInterface::asBinder(mComposerService)->linkToDeath(mDeathObserver);
Brian Lindahl9b85a192021-05-10 09:56:33 +0000127 return true;
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700128}
129
Andy McFadden6652b3e2012-09-06 18:45:56 -0700130/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() {
131 ComposerService& instance = ComposerService::getInstance();
132 Mutex::Autolock _l(instance.mLock);
Yi Kong48a619f2018-06-05 16:34:59 -0700133 if (instance.mComposerService == nullptr) {
Brian Lindahl9b85a192021-05-10 09:56:33 +0000134 if (ComposerService::getInstance().connectLocked()) {
135 ALOGD("ComposerService reconnected");
136 }
Andy McFadden6652b3e2012-09-06 18:45:56 -0700137 }
138 return instance.mComposerService;
139}
140
141void ComposerService::composerServiceDied()
142{
143 Mutex::Autolock _l(mLock);
Yi Kong48a619f2018-06-05 16:34:59 -0700144 mComposerService = nullptr;
145 mDeathObserver = nullptr;
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700146}
147
Huihong Luof5029222021-12-16 14:33:46 -0800148ComposerServiceAIDL::ComposerServiceAIDL() : Singleton<ComposerServiceAIDL>() {
149 std::scoped_lock lock(mMutex);
150 connectLocked();
151}
152
153bool ComposerServiceAIDL::connectLocked() {
154 const String16 name("SurfaceFlingerAIDL");
155 mComposerService = waitForService<gui::ISurfaceComposer>(name);
156 if (mComposerService == nullptr) {
157 return false; // fatal error or permission problem
158 }
159
160 // Create the death listener.
161 class DeathObserver : public IBinder::DeathRecipient {
162 ComposerServiceAIDL& mComposerService;
163 virtual void binderDied(const wp<IBinder>& who) {
164 ALOGW("ComposerService aidl remote (surfaceflinger) died [%p]", who.unsafe_get());
165 mComposerService.composerServiceDied();
166 }
167
168 public:
169 explicit DeathObserver(ComposerServiceAIDL& mgr) : mComposerService(mgr) {}
170 };
171
172 mDeathObserver = new DeathObserver(*const_cast<ComposerServiceAIDL*>(this));
173 IInterface::asBinder(mComposerService)->linkToDeath(mDeathObserver);
174 return true;
175}
176
177/*static*/ sp<gui::ISurfaceComposer> ComposerServiceAIDL::getComposerService() {
178 ComposerServiceAIDL& instance = ComposerServiceAIDL::getInstance();
179 std::scoped_lock lock(instance.mMutex);
180 if (instance.mComposerService == nullptr) {
181 if (ComposerServiceAIDL::getInstance().connectLocked()) {
182 ALOGD("ComposerServiceAIDL reconnected");
Huihong Luo02186fb2022-02-23 14:21:54 -0800183 WindowInfosListenerReporter::getInstance()->reconnect(instance.mComposerService);
Huihong Luof5029222021-12-16 14:33:46 -0800184 }
185 }
186 return instance.mComposerService;
187}
188
189void ComposerServiceAIDL::composerServiceDied() {
190 std::scoped_lock lock(mMutex);
191 mComposerService = nullptr;
192 mDeathObserver = nullptr;
193}
194
Robert Carrfb4d58b2019-01-15 09:21:27 -0800195class DefaultComposerClient: public Singleton<DefaultComposerClient> {
196 Mutex mLock;
197 sp<SurfaceComposerClient> mClient;
198 friend class Singleton<ComposerService>;
199public:
200 static sp<SurfaceComposerClient> getComposerClient() {
201 DefaultComposerClient& dc = DefaultComposerClient::getInstance();
202 Mutex::Autolock _l(dc.mLock);
203 if (dc.mClient == nullptr) {
204 dc.mClient = new SurfaceComposerClient;
205 }
206 return dc.mClient;
207 }
208};
209ANDROID_SINGLETON_STATIC_INSTANCE(DefaultComposerClient);
210
211
212sp<SurfaceComposerClient> SurfaceComposerClient::getDefault() {
213 return DefaultComposerClient::getComposerClient();
214}
215
Pascal Mütschardd56514e2024-05-24 17:37:13 +0200216// ---------------------------------------------------------------------------
217
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100218JankDataListener::~JankDataListener() {
219}
220
Pascal Mütschardd56514e2024-05-24 17:37:13 +0200221status_t JankDataListener::flushJankData() {
222 if (mLayerId == -1) {
223 return INVALID_OPERATION;
224 }
225
226 binder::Status status = ComposerServiceAIDL::getComposerService()->flushJankData(mLayerId);
227 return statusTFromBinderStatus(status);
228}
229
230std::mutex JankDataListenerFanOut::sFanoutInstanceMutex;
231std::unordered_map<int32_t, sp<JankDataListenerFanOut>> JankDataListenerFanOut::sFanoutInstances;
232
233binder::Status JankDataListenerFanOut::onJankData(const std::vector<gui::JankData>& jankData) {
234 // Find the highest VSync ID.
235 int64_t lastVsync = jankData.empty()
236 ? 0
237 : std::max_element(jankData.begin(), jankData.end(),
238 [](const gui::JankData& jd1, const gui::JankData& jd2) {
239 return jd1.frameVsyncId < jd2.frameVsyncId;
240 })
241 ->frameVsyncId;
242
243 // Fan out the jank data callback.
244 std::vector<wp<JankDataListener>> listenersToRemove;
245 for (auto listener : getActiveListeners()) {
246 if (!listener->onJankDataAvailable(jankData) ||
247 (listener->mRemoveAfter >= 0 && listener->mRemoveAfter <= lastVsync)) {
248 listenersToRemove.push_back(listener);
249 }
250 }
251
252 return removeListeners(listenersToRemove)
253 ? binder::Status::ok()
254 : binder::Status::fromExceptionCode(binder::Status::EX_NULL_POINTER);
255}
256
257status_t JankDataListenerFanOut::addListener(sp<SurfaceControl> sc, sp<JankDataListener> listener) {
258 sp<IBinder> layer = sc->getHandle();
259 if (layer == nullptr) {
260 return UNEXPECTED_NULL;
261 }
262 int32_t layerId = sc->getLayerId();
263
264 sFanoutInstanceMutex.lock();
265 auto it = sFanoutInstances.find(layerId);
266 bool registerNeeded = it == sFanoutInstances.end();
267 sp<JankDataListenerFanOut> fanout;
268 if (registerNeeded) {
269 fanout = sp<JankDataListenerFanOut>::make(layerId);
270 sFanoutInstances.insert({layerId, fanout});
271 } else {
272 fanout = it->second;
273 }
274
275 fanout->mMutex.lock();
276 fanout->mListeners.insert(listener);
277 fanout->mMutex.unlock();
278
279 sFanoutInstanceMutex.unlock();
280
281 if (registerNeeded) {
282 binder::Status status =
283 ComposerServiceAIDL::getComposerService()->addJankListener(layer, fanout);
284 return statusTFromBinderStatus(status);
285 }
286 return OK;
287}
288
289status_t JankDataListenerFanOut::removeListener(sp<JankDataListener> listener) {
290 int32_t layerId = listener->mLayerId;
291 if (layerId == -1) {
292 return INVALID_OPERATION;
293 }
294
295 int64_t removeAfter = INVALID_VSYNC;
296 sp<JankDataListenerFanOut> fanout;
297
298 sFanoutInstanceMutex.lock();
299 auto it = sFanoutInstances.find(layerId);
300 if (it != sFanoutInstances.end()) {
301 fanout = it->second;
302 removeAfter = fanout->updateAndGetRemovalVSync();
303 }
304
305 if (removeAfter != INVALID_VSYNC) {
306 // Remove this instance from the map, so that no new listeners are added
307 // while we're scheduled to be removed.
308 sFanoutInstances.erase(layerId);
309 }
310 sFanoutInstanceMutex.unlock();
311
312 if (removeAfter < 0) {
313 return OK;
314 }
315
316 binder::Status status =
317 ComposerServiceAIDL::getComposerService()->removeJankListener(layerId, fanout,
318 removeAfter);
319 return statusTFromBinderStatus(status);
320}
321
322std::vector<sp<JankDataListener>> JankDataListenerFanOut::getActiveListeners() {
323 std::scoped_lock<std::mutex> lock(mMutex);
324
325 std::vector<sp<JankDataListener>> listeners;
326 for (auto it = mListeners.begin(); it != mListeners.end();) {
327 auto listener = it->promote();
328 if (!listener) {
329 it = mListeners.erase(it);
330 } else {
331 listeners.push_back(std::move(listener));
332 it++;
333 }
334 }
335 return listeners;
336}
337
338bool JankDataListenerFanOut::removeListeners(const std::vector<wp<JankDataListener>>& listeners) {
339 std::scoped_lock<std::mutex> fanoutLock(sFanoutInstanceMutex);
340 std::scoped_lock<std::mutex> listenersLock(mMutex);
341
342 for (auto listener : listeners) {
343 mListeners.erase(listener);
344 }
345
346 if (mListeners.empty()) {
347 sFanoutInstances.erase(mLayerId);
348 return false;
349 }
350 return true;
351}
352
353int64_t JankDataListenerFanOut::updateAndGetRemovalVSync() {
354 std::scoped_lock<std::mutex> lock(mMutex);
355 if (mRemoveAfter >= 0) {
356 // We've already been scheduled to be removed. Don't schedule again.
357 return INVALID_VSYNC;
358 }
359
360 int64_t removeAfter = 0;
361 for (auto it = mListeners.begin(); it != mListeners.end();) {
362 auto listener = it->promote();
363 if (!listener) {
364 it = mListeners.erase(it);
365 } else if (listener->mRemoveAfter < 0) {
366 // We have at least one listener that's still interested. Don't remove.
367 return INVALID_VSYNC;
368 } else {
369 removeAfter = std::max(removeAfter, listener->mRemoveAfter);
370 it++;
371 }
372 }
373
374 mRemoveAfter = removeAfter;
375 return removeAfter;
376}
377
Mathias Agopian7e27f052010-05-28 14:22:23 -0700378// ---------------------------------------------------------------------------
379
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700380// TransactionCompletedListener does not use ANDROID_SINGLETON_STATIC_INSTANCE because it needs
381// to be able to return a sp<> to its instance to pass to SurfaceFlinger.
382// ANDROID_SINGLETON_STATIC_INSTANCE only allows a reference to an instance.
383
Marissa Wallc837b5e2018-10-12 10:04:44 -0700384// 0 is an invalid callback id
385TransactionCompletedListener::TransactionCompletedListener() : mCallbackIdCounter(1) {}
386
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700387int64_t TransactionCompletedListener::getNextIdLocked() {
Marissa Wallc837b5e2018-10-12 10:04:44 -0700388 return mCallbackIdCounter++;
389}
390
chaviw0b06a8d2021-08-06 11:49:08 -0500391sp<TransactionCompletedListener> TransactionCompletedListener::sInstance = nullptr;
Robert Carr2df7c452022-04-04 12:21:37 -0700392static std::mutex sListenerInstanceMutex;
chaviw0b06a8d2021-08-06 11:49:08 -0500393
394void TransactionCompletedListener::setInstance(const sp<TransactionCompletedListener>& listener) {
395 sInstance = listener;
396}
397
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700398sp<TransactionCompletedListener> TransactionCompletedListener::getInstance() {
Robert Carr2df7c452022-04-04 12:21:37 -0700399 std::lock_guard<std::mutex> lock(sListenerInstanceMutex);
chaviw0b06a8d2021-08-06 11:49:08 -0500400 if (sInstance == nullptr) {
401 sInstance = new TransactionCompletedListener;
402 }
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700403 return sInstance;
404}
405
Marissa Wallc837b5e2018-10-12 10:04:44 -0700406sp<ITransactionCompletedListener> TransactionCompletedListener::getIInstance() {
407 return static_cast<sp<ITransactionCompletedListener>>(getInstance());
408}
409
410void TransactionCompletedListener::startListeningLocked() {
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700411 if (mListening) {
412 return;
413 }
414 ProcessState::self()->startThreadPool();
415 mListening = true;
416}
417
Marissa Wall80d94ad2019-01-18 16:04:36 -0800418CallbackId TransactionCompletedListener::addCallbackFunction(
419 const TransactionCompletedCallback& callbackFunction,
420 const std::unordered_set<sp<SurfaceControl>, SurfaceComposerClient::SCHash>&
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700421 surfaceControls,
422 CallbackId::Type callbackType) {
Marissa Wallc837b5e2018-10-12 10:04:44 -0700423 std::lock_guard<std::mutex> lock(mMutex);
424 startListeningLocked();
425
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700426 CallbackId callbackId(getNextIdLocked(), callbackType);
Marissa Wall80d94ad2019-01-18 16:04:36 -0800427 mCallbacks[callbackId].callbackFunction = callbackFunction;
Marissa Wall80d94ad2019-01-18 16:04:36 -0800428 auto& callbackSurfaceControls = mCallbacks[callbackId].surfaceControls;
429
430 for (const auto& surfaceControl : surfaceControls) {
431 callbackSurfaceControls[surfaceControl->getHandle()] = surfaceControl;
432 }
433
Marissa Wallc837b5e2018-10-12 10:04:44 -0700434 return callbackId;
435}
436
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700437void TransactionCompletedListener::setReleaseBufferCallback(const ReleaseCallbackId& callbackId,
Vishnu Nair1506b182021-02-22 14:35:15 -0800438 ReleaseBufferCallback listener) {
439 std::scoped_lock<std::mutex> lock(mMutex);
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700440 mReleaseBufferCallbacks[callbackId] = listener;
Vishnu Nair1506b182021-02-22 14:35:15 -0800441}
442
Jorim Jaggif51775d2021-01-14 23:44:15 +0100443void TransactionCompletedListener::addSurfaceStatsListener(void* context, void* cookie,
444 sp<SurfaceControl> surfaceControl, SurfaceStatsCallback listener) {
Jorim Jaggi6ed2ea82021-06-16 17:49:08 +0200445 std::scoped_lock<std::recursive_mutex> lock(mSurfaceStatsListenerMutex);
chaviw29bc5362021-09-07 16:17:13 -0500446 mSurfaceStatsListeners.insert(
447 {surfaceControl->getLayerId(), SurfaceStatsCallbackEntry(context, cookie, listener)});
Jorim Jaggif51775d2021-01-14 23:44:15 +0100448}
449
450void TransactionCompletedListener::removeSurfaceStatsListener(void* context, void* cookie) {
Jorim Jaggi6ed2ea82021-06-16 17:49:08 +0200451 std::scoped_lock<std::recursive_mutex> lock(mSurfaceStatsListenerMutex);
Jorim Jaggif51775d2021-01-14 23:44:15 +0100452 for (auto it = mSurfaceStatsListeners.begin(); it != mSurfaceStatsListeners.end();) {
453 auto [itContext, itCookie, itListener] = it->second;
454 if (itContext == context && itCookie == cookie) {
455 it = mSurfaceStatsListeners.erase(it);
456 } else {
457 it++;
458 }
459 }
460}
461
Marissa Wall80d94ad2019-01-18 16:04:36 -0800462void TransactionCompletedListener::addSurfaceControlToCallbacks(
Pascal Mütschardd56514e2024-05-24 17:37:13 +0200463 const sp<SurfaceControl>& surfaceControl,
464 const std::unordered_set<CallbackId, CallbackIdHash>& callbackIds) {
Marissa Wall80d94ad2019-01-18 16:04:36 -0800465 std::lock_guard<std::mutex> lock(mMutex);
466
Pascal Mütschardd56514e2024-05-24 17:37:13 +0200467 for (auto callbackId : callbackIds) {
Marissa Wall80d94ad2019-01-18 16:04:36 -0800468 mCallbacks[callbackId].surfaceControls.emplace(std::piecewise_construct,
469 std::forward_as_tuple(
470 surfaceControl->getHandle()),
471 std::forward_as_tuple(surfaceControl));
472 }
473}
474
Huihong Luoffee3bc2023-01-17 16:14:35 +0000475void TransactionCompletedListener::onTransactionCompleted(ListenerStats listenerStats) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700476 std::unordered_map<CallbackId, CallbackTranslation, CallbackIdHash> callbacksMap;
Valerie Haud3b90d22019-11-06 09:37:31 -0800477 {
478 std::lock_guard<std::mutex> lock(mMutex);
Marissa Walle2ffb422018-10-12 11:33:52 -0700479
Valerie Haud3b90d22019-11-06 09:37:31 -0800480 /* This listener knows all the sp<IBinder> to sp<SurfaceControl> for all its registered
481 * callbackIds, except for when Transactions are merged together. This probably cannot be
482 * solved before this point because the Transactions could be merged together and applied in
483 * a different process.
484 *
485 * Fortunately, we get all the callbacks for this listener for the same frame together at
486 * the same time. This means if any Transactions were merged together, we will get their
487 * callbacks at the same time. We can combine all the sp<IBinder> to sp<SurfaceControl> maps
488 * for all the callbackIds to generate one super map that contains all the sp<IBinder> to
489 * sp<SurfaceControl> that could possibly exist for the callbacks.
490 */
491 callbacksMap = mCallbacks;
492 for (const auto& transactionStats : listenerStats.transactionStats) {
493 for (auto& callbackId : transactionStats.callbackIds) {
494 mCallbacks.erase(callbackId);
495 }
Marissa Wall80d94ad2019-01-18 16:04:36 -0800496 }
497 }
Marissa Walld600d572019-03-26 15:38:50 -0700498 for (const auto& transactionStats : listenerStats.transactionStats) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700499 // handle on commit callbacks
Marissa Walld600d572019-03-26 15:38:50 -0700500 for (auto callbackId : transactionStats.callbackIds) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700501 if (callbackId.type != CallbackId::Type::ON_COMMIT) {
502 continue;
503 }
504 auto& [callbackFunction, callbackSurfaceControls] = callbacksMap[callbackId];
505 if (!callbackFunction) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700506 continue;
507 }
508 std::vector<SurfaceControlStats> surfaceControlStats;
509 for (const auto& surfaceStats : transactionStats.surfaceStats) {
510 surfaceControlStats
511 .emplace_back(callbacksMap[callbackId]
512 .surfaceControls[surfaceStats.surfaceControl],
Ady Abraham461296a2022-01-21 11:11:31 -0800513 transactionStats.latchTime, surfaceStats.acquireTimeOrFence,
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700514 transactionStats.presentFence,
515 surfaceStats.previousReleaseFence, surfaceStats.transformHint,
Robert Carr405e2f62021-12-31 16:59:34 -0800516 surfaceStats.eventStats,
517 surfaceStats.currentMaxAcquiredBufferCount);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700518 }
519
520 callbackFunction(transactionStats.latchTime, transactionStats.presentFence,
521 surfaceControlStats);
Patrick Williams30da3672023-07-25 16:52:01 -0500522
523 // More than one transaction may contain the same callback id. Erase the callback from
524 // the map to ensure that it is only called once. This can happen if transactions are
525 // parcelled out of process and applied in both processes.
526 callbacksMap.erase(callbackId);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700527 }
528
529 // handle on complete callbacks
530 for (auto callbackId : transactionStats.callbackIds) {
531 if (callbackId.type != CallbackId::Type::ON_COMPLETE) {
532 continue;
533 }
Valerie Haud3b90d22019-11-06 09:37:31 -0800534 auto& [callbackFunction, callbackSurfaceControls] = callbacksMap[callbackId];
Marissa Wall80d94ad2019-01-18 16:04:36 -0800535 if (!callbackFunction) {
Marissa Walle2ffb422018-10-12 11:33:52 -0700536 ALOGE("cannot call null callback function, skipping");
537 continue;
538 }
Marissa Wall80d94ad2019-01-18 16:04:36 -0800539 std::vector<SurfaceControlStats> surfaceControlStats;
540 for (const auto& surfaceStats : transactionStats.surfaceStats) {
Valerie Haud3b90d22019-11-06 09:37:31 -0800541 surfaceControlStats
542 .emplace_back(callbacksMap[callbackId]
543 .surfaceControls[surfaceStats.surfaceControl],
Ady Abraham461296a2022-01-21 11:11:31 -0800544 transactionStats.latchTime, surfaceStats.acquireTimeOrFence,
Valerie Hau871d6352020-01-29 08:44:02 -0800545 transactionStats.presentFence,
546 surfaceStats.previousReleaseFence, surfaceStats.transformHint,
Robert Carr405e2f62021-12-31 16:59:34 -0800547 surfaceStats.eventStats,
548 surfaceStats.currentMaxAcquiredBufferCount);
Vishnu Nair71fcf912022-10-18 09:14:20 -0700549 if (callbacksMap[callbackId].surfaceControls[surfaceStats.surfaceControl] &&
550 surfaceStats.transformHint.has_value()) {
Valerie Hau84d87ff2020-01-08 17:23:21 -0800551 callbacksMap[callbackId]
552 .surfaceControls[surfaceStats.surfaceControl]
Vishnu Nair71fcf912022-10-18 09:14:20 -0700553 ->setTransformHint(*surfaceStats.transformHint);
Valerie Hau84d87ff2020-01-08 17:23:21 -0800554 }
Vishnu Nair1506b182021-02-22 14:35:15 -0800555 // If there is buffer id set, we look up any pending client release buffer callbacks
556 // and call them. This is a performance optimization when we have a transaction
557 // callback and a release buffer callback happening at the same time to avoid an
558 // additional ipc call from the server.
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700559 if (surfaceStats.previousReleaseCallbackId != ReleaseCallbackId::INVALID_ID) {
Vishnu Nair5faedf52021-03-22 11:32:58 -0700560 ReleaseBufferCallback callback;
561 {
562 std::scoped_lock<std::mutex> lock(mMutex);
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700563 callback = popReleaseBufferCallbackLocked(
564 surfaceStats.previousReleaseCallbackId);
Vishnu Nair5faedf52021-03-22 11:32:58 -0700565 }
Vishnu Nair1506b182021-02-22 14:35:15 -0800566 if (callback) {
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700567 callback(surfaceStats.previousReleaseCallbackId,
Vishnu Nair1506b182021-02-22 14:35:15 -0800568 surfaceStats.previousReleaseFence
569 ? surfaceStats.previousReleaseFence
Robert Carr97e7cc02021-06-07 10:45:40 -0700570 : Fence::NO_FENCE,
Ady Abraham899dcdb2021-06-15 16:56:21 -0700571 surfaceStats.currentMaxAcquiredBufferCount);
Vishnu Nair1506b182021-02-22 14:35:15 -0800572 }
573 }
Marissa Wall80d94ad2019-01-18 16:04:36 -0800574 }
575
576 callbackFunction(transactionStats.latchTime, transactionStats.presentFence,
577 surfaceControlStats);
Marissa Walle2ffb422018-10-12 11:33:52 -0700578 }
Vishnu Nair6f4d2f52023-08-10 12:33:12 -0700579 }
chaviw29bc5362021-09-07 16:17:13 -0500580
Vishnu Nair6f4d2f52023-08-10 12:33:12 -0700581 for (const auto& transactionStats : listenerStats.transactionStats) {
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100582 for (const auto& surfaceStats : transactionStats.surfaceStats) {
chaviw29bc5362021-09-07 16:17:13 -0500583 // The callbackMap contains the SurfaceControl object, which we need to look up the
584 // layerId. Since we don't know which callback contains the SurfaceControl, iterate
585 // through all until the SC is found.
586 int32_t layerId = -1;
587 for (auto callbackId : transactionStats.callbackIds) {
Pablo Gamito10026472021-11-22 22:16:45 +0100588 if (callbackId.type != CallbackId::Type::ON_COMPLETE) {
589 // We only want to run the stats callback for ON_COMPLETE
590 continue;
591 }
chaviw29bc5362021-09-07 16:17:13 -0500592 sp<SurfaceControl> sc =
593 callbacksMap[callbackId].surfaceControls[surfaceStats.surfaceControl];
594 if (sc != nullptr) {
595 layerId = sc->getLayerId();
596 break;
597 }
598 }
599
Pablo Gamito10026472021-11-22 22:16:45 +0100600 if (layerId != -1) {
Jorim Jaggi6ed2ea82021-06-16 17:49:08 +0200601 // Acquire surface stats listener lock such that we guarantee that after calling
602 // unregister, there won't be any further callback.
603 std::scoped_lock<std::recursive_mutex> lock(mSurfaceStatsListenerMutex);
chaviw29bc5362021-09-07 16:17:13 -0500604 auto listenerRange = mSurfaceStatsListeners.equal_range(layerId);
Jorim Jaggi6ed2ea82021-06-16 17:49:08 +0200605 for (auto it = listenerRange.first; it != listenerRange.second; it++) {
606 auto entry = it->second;
607 entry.callback(entry.context, transactionStats.latchTime,
608 transactionStats.presentFence, surfaceStats);
609 }
Jorim Jaggif51775d2021-01-14 23:44:15 +0100610 }
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100611 }
Marissa Walle2ffb422018-10-12 11:33:52 -0700612 }
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700613}
614
Huihong Luoffee3bc2023-01-17 16:14:35 +0000615void TransactionCompletedListener::onTransactionQueueStalled(const String8& reason) {
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000616 std::unordered_map<void*, std::function<void(const std::string&)>> callbackCopy;
617 {
618 std::scoped_lock<std::mutex> lock(mMutex);
619 callbackCopy = mQueueStallListeners;
620 }
621 for (auto const& it : callbackCopy) {
622 it.second(reason.c_str());
623 }
Robert Carr4c1b6462021-12-21 10:30:50 -0800624}
625
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000626void TransactionCompletedListener::addQueueStallListener(
627 std::function<void(const std::string&)> stallListener, void* id) {
Robert Carr4c1b6462021-12-21 10:30:50 -0800628 std::scoped_lock<std::mutex> lock(mMutex);
629 mQueueStallListeners[id] = stallListener;
630}
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000631
632void TransactionCompletedListener::removeQueueStallListener(void* id) {
Robert Carr4c1b6462021-12-21 10:30:50 -0800633 std::scoped_lock<std::mutex> lock(mMutex);
634 mQueueStallListeners.erase(id);
635}
636
Huihong Luoffee3bc2023-01-17 16:14:35 +0000637void TransactionCompletedListener::onReleaseBuffer(ReleaseCallbackId callbackId,
638 sp<Fence> releaseFence,
639 uint32_t currentMaxAcquiredBufferCount) {
Vishnu Nair1506b182021-02-22 14:35:15 -0800640 ReleaseBufferCallback callback;
641 {
642 std::scoped_lock<std::mutex> lock(mMutex);
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700643 callback = popReleaseBufferCallbackLocked(callbackId);
Vishnu Nair1506b182021-02-22 14:35:15 -0800644 }
645 if (!callback) {
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700646 ALOGE("Could not call release buffer callback, buffer not found %s",
647 callbackId.to_string().c_str());
Huihong Luoffee3bc2023-01-17 16:14:35 +0000648 return;
Vishnu Nair1506b182021-02-22 14:35:15 -0800649 }
chaviw69058fb2021-09-27 09:37:30 -0500650 std::optional<uint32_t> optionalMaxAcquiredBufferCount =
Huihong Luoffee3bc2023-01-17 16:14:35 +0000651 currentMaxAcquiredBufferCount == UINT_MAX
chaviw69058fb2021-09-27 09:37:30 -0500652 ? std::nullopt
653 : std::make_optional<uint32_t>(currentMaxAcquiredBufferCount);
654 callback(callbackId, releaseFence, optionalMaxAcquiredBufferCount);
Vishnu Nair1506b182021-02-22 14:35:15 -0800655}
656
657ReleaseBufferCallback TransactionCompletedListener::popReleaseBufferCallbackLocked(
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700658 const ReleaseCallbackId& callbackId) {
Vishnu Nair1506b182021-02-22 14:35:15 -0800659 ReleaseBufferCallback callback;
Vishnu Nair4ba0c2e2021-06-24 11:27:17 -0700660 auto itr = mReleaseBufferCallbacks.find(callbackId);
Vishnu Nair1506b182021-02-22 14:35:15 -0800661 if (itr == mReleaseBufferCallbacks.end()) {
662 return nullptr;
663 }
664 callback = itr->second;
665 mReleaseBufferCallbacks.erase(itr);
666 return callback;
667}
668
chaviw0acd33a2021-11-02 11:55:37 -0500669void TransactionCompletedListener::removeReleaseBufferCallback(
670 const ReleaseCallbackId& callbackId) {
671 {
672 std::scoped_lock<std::mutex> lock(mMutex);
673 popReleaseBufferCallbackLocked(callbackId);
674 }
675}
676
Chavi Weingarten076acac2023-01-19 17:20:43 +0000677SurfaceComposerClient::PresentationCallbackRAII::PresentationCallbackRAII(
678 TransactionCompletedListener* tcl, int id) {
679 mTcl = tcl;
680 mId = id;
681}
682
683SurfaceComposerClient::PresentationCallbackRAII::~PresentationCallbackRAII() {
684 mTcl->clearTrustedPresentationCallback(mId);
685}
686
687sp<SurfaceComposerClient::PresentationCallbackRAII>
688TransactionCompletedListener::addTrustedPresentationCallback(TrustedPresentationCallback tpc,
689 int id, void* context) {
690 std::scoped_lock<std::mutex> lock(mMutex);
691 mTrustedPresentationCallbacks[id] =
692 std::tuple<TrustedPresentationCallback, void*>(tpc, context);
693 return new SurfaceComposerClient::PresentationCallbackRAII(this, id);
694}
695
696void TransactionCompletedListener::clearTrustedPresentationCallback(int id) {
697 std::scoped_lock<std::mutex> lock(mMutex);
698 mTrustedPresentationCallbacks.erase(id);
699}
700
701void TransactionCompletedListener::onTrustedPresentationChanged(int id,
702 bool presentedWithinThresholds) {
703 TrustedPresentationCallback tpc;
704 void* context;
705 {
706 std::scoped_lock<std::mutex> lock(mMutex);
707 auto it = mTrustedPresentationCallbacks.find(id);
708 if (it == mTrustedPresentationCallbacks.end()) {
709 return;
710 }
711 std::tie(tpc, context) = it->second;
712 }
713 tpc(context, presentedWithinThresholds);
714}
715
Marissa Wall7a9b6ff2018-08-21 17:26:20 -0700716// ---------------------------------------------------------------------------
717
Robert Carre06ad2b2020-04-10 15:09:33 -0700718void removeDeadBufferCallback(void* /*context*/, uint64_t graphicBufferId);
Marissa Wall78b72202019-03-15 14:58:34 -0700719
Robert Carre06ad2b2020-04-10 15:09:33 -0700720/**
721 * We use the BufferCache to reduce the overhead of exchanging GraphicBuffers with
722 * the server. If we were to simply parcel the GraphicBuffer we would pay two overheads
723 * 1. Cost of sending the FD
724 * 2. Cost of importing the GraphicBuffer with the mapper in the receiving process.
725 * To ease this cost we implement the following scheme of caching buffers to integers,
726 * or said-otherwise, naming them with integers. This is the scheme known as slots in
727 * the legacy BufferQueue system.
728 * 1. When sending Buffers to SurfaceFlinger we look up the Buffer in the cache.
729 * 2. If there is a cache-hit we remove the Buffer from the Transaction and instead
730 * send the cached integer.
731 * 3. If there is a cache miss, we cache the new buffer and send the integer
732 * along with the Buffer, SurfaceFlinger on it's side creates a new cache
733 * entry, and we use the integer for further communication.
734 * A few details about lifetime:
735 * 1. The cache evicts by LRU. The server side cache is keyed by BufferCache::getToken
736 * which is per process Unique. The server side cache is larger than the client side
737 * cache so that the server will never evict entries before the client.
738 * 2. When the client evicts an entry it notifies the server via an uncacheBuffer
739 * transaction.
740 * 3. The client only references the Buffers by ID, and uses buffer->addDeathCallback
741 * to auto-evict destroyed buffers.
742 */
Marissa Wall73411622019-01-25 10:45:41 -0800743class BufferCache : public Singleton<BufferCache> {
744public:
745 BufferCache() : token(new BBinder()) {}
746
747 sp<IBinder> getToken() {
748 return IInterface::asBinder(TransactionCompletedListener::getIInstance());
749 }
750
Marissa Wall78b72202019-03-15 14:58:34 -0700751 status_t getCacheId(const sp<GraphicBuffer>& buffer, uint64_t* cacheId) {
Yi Kongd2639aa2019-02-28 11:58:32 -0800752 std::lock_guard<std::mutex> lock(mMutex);
Marissa Wall73411622019-01-25 10:45:41 -0800753
Marissa Wall78b72202019-03-15 14:58:34 -0700754 auto itr = mBuffers.find(buffer->getId());
Marissa Wall73411622019-01-25 10:45:41 -0800755 if (itr == mBuffers.end()) {
Marissa Wall78b72202019-03-15 14:58:34 -0700756 return BAD_VALUE;
Marissa Wall73411622019-01-25 10:45:41 -0800757 }
Marissa Wall78b72202019-03-15 14:58:34 -0700758 itr->second = getCounter();
759 *cacheId = buffer->getId();
760 return NO_ERROR;
Marissa Wall73411622019-01-25 10:45:41 -0800761 }
762
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000763 uint64_t cache(const sp<GraphicBuffer>& buffer,
764 std::optional<client_cache_t>& outUncacheBuffer) {
Yi Kongd2639aa2019-02-28 11:58:32 -0800765 std::lock_guard<std::mutex> lock(mMutex);
Marissa Wall73411622019-01-25 10:45:41 -0800766
Marissa Wall78b72202019-03-15 14:58:34 -0700767 if (mBuffers.size() >= BUFFER_CACHE_MAX_SIZE) {
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000768 outUncacheBuffer = findLeastRecentlyUsedBuffer();
769 mBuffers.erase(outUncacheBuffer->id);
Marissa Wall78b72202019-03-15 14:58:34 -0700770 }
Marissa Wall73411622019-01-25 10:45:41 -0800771
Robert Carre06ad2b2020-04-10 15:09:33 -0700772 buffer->addDeathCallback(removeDeadBufferCallback, nullptr);
Marissa Wall78b72202019-03-15 14:58:34 -0700773
774 mBuffers[buffer->getId()] = getCounter();
775 return buffer->getId();
776 }
777
778 void uncache(uint64_t cacheId) {
779 std::lock_guard<std::mutex> lock(mMutex);
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000780 if (mBuffers.erase(cacheId)) {
781 SurfaceComposerClient::doUncacheBufferTransaction(cacheId);
782 }
Marissa Wall73411622019-01-25 10:45:41 -0800783 }
784
785private:
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000786 client_cache_t findLeastRecentlyUsedBuffer() REQUIRES(mMutex) {
Marissa Wall73411622019-01-25 10:45:41 -0800787 auto itr = mBuffers.begin();
Marissa Wall78b72202019-03-15 14:58:34 -0700788 uint64_t minCounter = itr->second;
Marissa Wall73411622019-01-25 10:45:41 -0800789 auto minBuffer = itr;
790 itr++;
791
792 while (itr != mBuffers.end()) {
Marissa Wall78b72202019-03-15 14:58:34 -0700793 uint64_t counter = itr->second;
Marissa Wall73411622019-01-25 10:45:41 -0800794 if (counter < minCounter) {
795 minCounter = counter;
796 minBuffer = itr;
797 }
798 itr++;
799 }
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000800
801 return {.token = getToken(), .id = minBuffer->first};
Marissa Wall73411622019-01-25 10:45:41 -0800802 }
803
804 uint64_t getCounter() REQUIRES(mMutex) {
805 static uint64_t counter = 0;
806 return counter++;
807 }
808
Marissa Wall73411622019-01-25 10:45:41 -0800809 std::mutex mMutex;
Marissa Wall78b72202019-03-15 14:58:34 -0700810 std::map<uint64_t /*Cache id*/, uint64_t /*counter*/> mBuffers GUARDED_BY(mMutex);
Marissa Wall73411622019-01-25 10:45:41 -0800811
812 // Used by ISurfaceComposer to identify which process is sending the cached buffer.
813 sp<IBinder> token;
814};
815
816ANDROID_SINGLETON_STATIC_INSTANCE(BufferCache);
817
Robert Carre06ad2b2020-04-10 15:09:33 -0700818void removeDeadBufferCallback(void* /*context*/, uint64_t graphicBufferId) {
Marissa Wall78b72202019-03-15 14:58:34 -0700819 // GraphicBuffer id's are used as the cache ids.
820 BufferCache::getInstance().uncache(graphicBufferId);
821}
822
Marissa Wall73411622019-01-25 10:45:41 -0800823// ---------------------------------------------------------------------------
824
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000825SurfaceComposerClient::Transaction::Transaction() {
826 mId = generateId();
Vishnu Naira74ba0f2024-04-16 11:25:06 -0700827 mTransactionCompletedListener = TransactionCompletedListener::getInstance();
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000828}
829
Marissa Wall17b4e452018-12-26 16:32:34 -0800830SurfaceComposerClient::Transaction::Transaction(const Transaction& other)
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000831 : mId(other.mId),
Marissa Wall17b4e452018-12-26 16:32:34 -0800832 mAnimation(other.mAnimation),
Ady Abraham8cbd3072021-03-15 16:39:06 -0700833 mEarlyWakeupStart(other.mEarlyWakeupStart),
834 mEarlyWakeupEnd(other.mEarlyWakeupEnd),
Chavi Weingarten1ac2a922022-09-15 20:34:48 +0000835 mMayContainBuffer(other.mMayContainBuffer),
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700836 mDesiredPresentTime(other.mDesiredPresentTime),
Ady Abrahamf0c56492020-12-17 18:04:15 -0800837 mIsAutoTimestamp(other.mIsAutoTimestamp),
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000838 mFrameTimelineInfo(other.mFrameTimelineInfo),
Patrick Williamse5991f52022-06-23 20:23:43 +0000839 mApplyToken(other.mApplyToken) {
Robert Carr4cdc58f2017-08-23 14:22:20 -0700840 mDisplayStates = other.mDisplayStates;
841 mComposerStates = other.mComposerStates;
chaviw273171b2018-12-26 11:46:30 -0800842 mInputWindowCommands = other.mInputWindowCommands;
Vishnu Nair621102e2019-06-12 14:16:57 -0700843 mListenerCallbacks = other.mListenerCallbacks;
Vishnu Naira74ba0f2024-04-16 11:25:06 -0700844 mTransactionCompletedListener = TransactionCompletedListener::getInstance();
Vishnu Nair621102e2019-06-12 14:16:57 -0700845}
846
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000847void SurfaceComposerClient::Transaction::sanitize(int pid, int uid) {
848 uint32_t permissions = LayerStatePermissions::getTransactionPermissions(pid, uid);
Robert Carrde6d7b42022-01-07 18:23:06 -0800849 for (auto & [handle, composerState] : mComposerStates) {
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000850 composerState.state.sanitize(permissions);
Robert Carrde6d7b42022-01-07 18:23:06 -0800851 }
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000852 if (!mInputWindowCommands.empty() &&
853 (permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) == 0) {
854 ALOGE("Only privileged callers are allowed to send input commands.");
855 mInputWindowCommands.clear();
856 }
Robert Carrde6d7b42022-01-07 18:23:06 -0800857}
858
Vishnu Nair621102e2019-06-12 14:16:57 -0700859std::unique_ptr<SurfaceComposerClient::Transaction>
860SurfaceComposerClient::Transaction::createFromParcel(const Parcel* parcel) {
861 auto transaction = std::make_unique<Transaction>();
862 if (transaction->readFromParcel(parcel) == NO_ERROR) {
863 return transaction;
864 }
865 return nullptr;
866}
867
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000868
Vishnu Nair621102e2019-06-12 14:16:57 -0700869status_t SurfaceComposerClient::Transaction::readFromParcel(const Parcel* parcel) {
Pablo Gamito825df7f2022-06-23 14:45:44 +0000870 const uint64_t transactionId = parcel->readUint64();
Vishnu Nair621102e2019-06-12 14:16:57 -0700871 const bool animation = parcel->readBool();
Ady Abraham8cbd3072021-03-15 16:39:06 -0700872 const bool earlyWakeupStart = parcel->readBool();
873 const bool earlyWakeupEnd = parcel->readBool();
Vishnu Nair621102e2019-06-12 14:16:57 -0700874 const int64_t desiredPresentTime = parcel->readInt64();
Ady Abrahamf0c56492020-12-17 18:04:15 -0800875 const bool isAutoTimestamp = parcel->readBool();
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000876 FrameTimelineInfo frameTimelineInfo;
Huihong Luo3bdef862022-03-03 11:57:19 -0800877 frameTimelineInfo.readFromParcel(parcel);
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000878
Vishnu Nair277142c2021-01-05 18:35:29 -0800879 sp<IBinder> applyToken;
880 parcel->readNullableStrongBinder(&applyToken);
Vishnu Nair621102e2019-06-12 14:16:57 -0700881 size_t count = static_cast<size_t>(parcel->readUint32());
882 if (count > parcel->dataSize()) {
883 return BAD_VALUE;
884 }
885 SortedVector<DisplayState> displayStates;
886 displayStates.setCapacity(count);
887 for (size_t i = 0; i < count; i++) {
888 DisplayState displayState;
889 if (displayState.read(*parcel) == BAD_VALUE) {
890 return BAD_VALUE;
891 }
892 displayStates.add(displayState);
893 }
894
895 count = static_cast<size_t>(parcel->readUint32());
896 if (count > parcel->dataSize()) {
897 return BAD_VALUE;
898 }
Valerie Hau9dab9732019-08-20 09:29:25 -0700899 std::unordered_map<sp<ITransactionCompletedListener>, CallbackInfo, TCLHash> listenerCallbacks;
900 listenerCallbacks.reserve(count);
901 for (size_t i = 0; i < count; i++) {
902 sp<ITransactionCompletedListener> listener =
903 interface_cast<ITransactionCompletedListener>(parcel->readStrongBinder());
904 size_t numCallbackIds = parcel->readUint32();
905 if (numCallbackIds > parcel->dataSize()) {
906 return BAD_VALUE;
907 }
908 for (size_t j = 0; j < numCallbackIds; j++) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -0700909 CallbackId id;
910 parcel->readParcelable(&id);
911 listenerCallbacks[listener].callbackIds.insert(id);
Valerie Hau9dab9732019-08-20 09:29:25 -0700912 }
913 size_t numSurfaces = parcel->readUint32();
914 if (numSurfaces > parcel->dataSize()) {
915 return BAD_VALUE;
916 }
917 for (size_t j = 0; j < numSurfaces; j++) {
918 sp<SurfaceControl> surface;
Pablo Gamito421dfd52020-09-22 18:11:45 +0000919 SAFE_PARCEL(SurfaceControl::readFromParcel, *parcel, &surface);
Valerie Hau9dab9732019-08-20 09:29:25 -0700920 listenerCallbacks[listener].surfaceControls.insert(surface);
921 }
922 }
923
924 count = static_cast<size_t>(parcel->readUint32());
925 if (count > parcel->dataSize()) {
926 return BAD_VALUE;
927 }
Vishnu Nairf03652d2019-07-16 17:56:56 -0700928 std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> composerStates;
Vishnu Nair621102e2019-06-12 14:16:57 -0700929 composerStates.reserve(count);
930 for (size_t i = 0; i < count; i++) {
Pablo Gamitodbc31672020-09-01 18:28:58 +0000931 sp<IBinder> surfaceControlHandle;
932 SAFE_PARCEL(parcel->readStrongBinder, &surfaceControlHandle);
Vishnu Nair621102e2019-06-12 14:16:57 -0700933
934 ComposerState composerState;
935 if (composerState.read(*parcel) == BAD_VALUE) {
936 return BAD_VALUE;
937 }
Vishnu Nairf03652d2019-07-16 17:56:56 -0700938 composerStates[surfaceControlHandle] = composerState;
Vishnu Nair621102e2019-06-12 14:16:57 -0700939 }
940
941 InputWindowCommands inputWindowCommands;
942 inputWindowCommands.read(*parcel);
943
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000944 count = static_cast<size_t>(parcel->readUint32());
945 if (count > parcel->dataSize()) {
946 return BAD_VALUE;
947 }
948 std::vector<client_cache_t> uncacheBuffers(count);
949 for (size_t i = 0; i < count; i++) {
950 sp<IBinder> tmpBinder;
951 SAFE_PARCEL(parcel->readStrongBinder, &tmpBinder);
952 uncacheBuffers[i].token = tmpBinder;
953 SAFE_PARCEL(parcel->readUint64, &uncacheBuffers[i].id);
954 }
955
Pablo Gamito23780be2023-04-18 08:30:00 +0000956 count = static_cast<size_t>(parcel->readUint32());
957 if (count > parcel->dataSize()) {
958 return BAD_VALUE;
959 }
960 std::vector<uint64_t> mergedTransactionIds(count);
961 for (size_t i = 0; i < count; i++) {
962 SAFE_PARCEL(parcel->readUint64, &mergedTransactionIds[i]);
963 }
964
Vishnu Nair621102e2019-06-12 14:16:57 -0700965 // Parsing was successful. Update the object.
Pablo Gamito825df7f2022-06-23 14:45:44 +0000966 mId = transactionId;
Vishnu Nair621102e2019-06-12 14:16:57 -0700967 mAnimation = animation;
Ady Abraham8cbd3072021-03-15 16:39:06 -0700968 mEarlyWakeupStart = earlyWakeupStart;
969 mEarlyWakeupEnd = earlyWakeupEnd;
Vishnu Nair621102e2019-06-12 14:16:57 -0700970 mDesiredPresentTime = desiredPresentTime;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800971 mIsAutoTimestamp = isAutoTimestamp;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000972 mFrameTimelineInfo = frameTimelineInfo;
Vishnu Nair621102e2019-06-12 14:16:57 -0700973 mDisplayStates = displayStates;
Valerie Hau9dab9732019-08-20 09:29:25 -0700974 mListenerCallbacks = listenerCallbacks;
Vishnu Nair621102e2019-06-12 14:16:57 -0700975 mComposerStates = composerStates;
976 mInputWindowCommands = inputWindowCommands;
Vishnu Nair277142c2021-01-05 18:35:29 -0800977 mApplyToken = applyToken;
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000978 mUncacheBuffers = std::move(uncacheBuffers);
Pablo Gamito23780be2023-04-18 08:30:00 +0000979 mMergedTransactionIds = std::move(mergedTransactionIds);
Vishnu Nair621102e2019-06-12 14:16:57 -0700980 return NO_ERROR;
981}
982
983status_t SurfaceComposerClient::Transaction::writeToParcel(Parcel* parcel) const {
Robert Carr158531d2020-04-08 10:53:30 -0700984 // If we write the Transaction to a parcel, we want to ensure the Buffers are cached
985 // before crossing the IPC boundary. Otherwise the receiving party will cache the buffers
986 // but is unlikely to use them again as they are owned by the other process.
987 // You may be asking yourself, is this const cast safe? Const cast is safe up
988 // until the point where you try and write to an object that was originally const at which
989 // point we enter undefined behavior. In this case we are safe though, because there are
990 // two possibilities:
991 // 1. The SurfaceComposerClient::Transaction was originally non-const. Safe.
992 // 2. It was originall const! In this case not only was it useless, but it by definition
993 // contains no composer states and so cacheBuffers will not perform any writes.
994
995 const_cast<SurfaceComposerClient::Transaction*>(this)->cacheBuffers();
996
Pablo Gamito825df7f2022-06-23 14:45:44 +0000997 parcel->writeUint64(mId);
Vishnu Nair621102e2019-06-12 14:16:57 -0700998 parcel->writeBool(mAnimation);
Ady Abraham8cbd3072021-03-15 16:39:06 -0700999 parcel->writeBool(mEarlyWakeupStart);
1000 parcel->writeBool(mEarlyWakeupEnd);
Vishnu Nair621102e2019-06-12 14:16:57 -07001001 parcel->writeInt64(mDesiredPresentTime);
Ady Abrahamf0c56492020-12-17 18:04:15 -08001002 parcel->writeBool(mIsAutoTimestamp);
Huihong Luo3bdef862022-03-03 11:57:19 -08001003 mFrameTimelineInfo.writeToParcel(parcel);
Vishnu Nair277142c2021-01-05 18:35:29 -08001004 parcel->writeStrongBinder(mApplyToken);
Vishnu Nair621102e2019-06-12 14:16:57 -07001005 parcel->writeUint32(static_cast<uint32_t>(mDisplayStates.size()));
1006 for (auto const& displayState : mDisplayStates) {
1007 displayState.write(*parcel);
1008 }
1009
Valerie Hau9dab9732019-08-20 09:29:25 -07001010 parcel->writeUint32(static_cast<uint32_t>(mListenerCallbacks.size()));
1011 for (auto const& [listener, callbackInfo] : mListenerCallbacks) {
1012 parcel->writeStrongBinder(ITransactionCompletedListener::asBinder(listener));
1013 parcel->writeUint32(static_cast<uint32_t>(callbackInfo.callbackIds.size()));
1014 for (auto callbackId : callbackInfo.callbackIds) {
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07001015 parcel->writeParcelable(callbackId);
Valerie Hau9dab9732019-08-20 09:29:25 -07001016 }
1017 parcel->writeUint32(static_cast<uint32_t>(callbackInfo.surfaceControls.size()));
1018 for (auto surfaceControl : callbackInfo.surfaceControls) {
Pablo Gamito421dfd52020-09-22 18:11:45 +00001019 SAFE_PARCEL(surfaceControl->writeToParcel, *parcel);
Valerie Hau9dab9732019-08-20 09:29:25 -07001020 }
1021 }
1022
Vishnu Nair621102e2019-06-12 14:16:57 -07001023 parcel->writeUint32(static_cast<uint32_t>(mComposerStates.size()));
Pablo Gamitodbc31672020-09-01 18:28:58 +00001024 for (auto const& [handle, composerState] : mComposerStates) {
1025 SAFE_PARCEL(parcel->writeStrongBinder, handle);
Vishnu Nair621102e2019-06-12 14:16:57 -07001026 composerState.write(*parcel);
1027 }
1028
1029 mInputWindowCommands.write(*parcel);
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00001030
1031 SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mUncacheBuffers.size()));
1032 for (const client_cache_t& uncacheBuffer : mUncacheBuffers) {
1033 SAFE_PARCEL(parcel->writeStrongBinder, uncacheBuffer.token.promote());
1034 SAFE_PARCEL(parcel->writeUint64, uncacheBuffer.id);
1035 }
1036
Pablo Gamito23780be2023-04-18 08:30:00 +00001037 SAFE_PARCEL(parcel->writeUint32, static_cast<uint32_t>(mMergedTransactionIds.size()));
1038 for (auto mergedTransactionId : mMergedTransactionIds) {
1039 SAFE_PARCEL(parcel->writeUint64, mergedTransactionId);
1040 }
1041
Vishnu Nair621102e2019-06-12 14:16:57 -07001042 return NO_ERROR;
Mathias Agopian698c0872011-06-28 19:09:31 -07001043}
1044
chaviw69058fb2021-09-27 09:37:30 -05001045void SurfaceComposerClient::Transaction::releaseBufferIfOverwriting(const layer_state_t& state) {
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001046 if (!(state.what & layer_state_t::eBufferChanged) || !state.bufferData->hasBuffer()) {
chaviw69058fb2021-09-27 09:37:30 -05001047 return;
1048 }
1049
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001050 auto listener = state.bufferData->releaseBufferListener;
chaviw69058fb2021-09-27 09:37:30 -05001051 sp<Fence> fence =
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001052 state.bufferData->acquireFence ? state.bufferData->acquireFence : Fence::NO_FENCE;
1053 if (state.bufferData->releaseBufferEndpoint ==
chaviw69058fb2021-09-27 09:37:30 -05001054 IInterface::asBinder(TransactionCompletedListener::getIInstance())) {
1055 // if the callback is in process, run on a different thread to avoid any lock contigency
1056 // issues in the client.
1057 SurfaceComposerClient::getDefault()
chaviw8dd181f2022-01-05 18:36:46 -06001058 ->mReleaseCallbackThread
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001059 .addReleaseCallback(state.bufferData->generateReleaseCallbackId(), fence);
chaviw69058fb2021-09-27 09:37:30 -05001060 } else {
Huihong Luoffee3bc2023-01-17 16:14:35 +00001061 listener->onReleaseBuffer(state.bufferData->generateReleaseCallbackId(), fence, UINT_MAX);
chaviw69058fb2021-09-27 09:37:30 -05001062 }
1063}
1064
Robert Carr2c5f6d22017-09-26 12:30:35 -07001065SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::merge(Transaction&& other) {
Pablo Gamito23780be2023-04-18 08:30:00 +00001066 while (mMergedTransactionIds.size() + other.mMergedTransactionIds.size() >
1067 MAX_MERGE_HISTORY_LENGTH - 1 &&
1068 mMergedTransactionIds.size() > 0) {
1069 mMergedTransactionIds.pop_back();
1070 }
1071 if (other.mMergedTransactionIds.size() == MAX_MERGE_HISTORY_LENGTH) {
1072 mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
1073 other.mMergedTransactionIds.begin(),
1074 other.mMergedTransactionIds.end() - 1);
1075 } else if (other.mMergedTransactionIds.size() > 0u) {
1076 mMergedTransactionIds.insert(mMergedTransactionIds.begin(),
1077 other.mMergedTransactionIds.begin(),
1078 other.mMergedTransactionIds.end());
1079 }
1080 mMergedTransactionIds.insert(mMergedTransactionIds.begin(), other.mId);
1081
Pablo Gamitodbc31672020-09-01 18:28:58 +00001082 for (auto const& [handle, composerState] : other.mComposerStates) {
1083 if (mComposerStates.count(handle) == 0) {
1084 mComposerStates[handle] = composerState;
Robert Carr2c5f6d22017-09-26 12:30:35 -07001085 } else {
chaviw69058fb2021-09-27 09:37:30 -05001086 if (composerState.state.what & layer_state_t::eBufferChanged) {
1087 releaseBufferIfOverwriting(mComposerStates[handle].state);
1088 }
Pablo Gamitodbc31672020-09-01 18:28:58 +00001089 mComposerStates[handle].state.merge(composerState.state);
Robert Carr2c5f6d22017-09-26 12:30:35 -07001090 }
1091 }
Robert Carr2c5f6d22017-09-26 12:30:35 -07001092
1093 for (auto const& state : other.mDisplayStates) {
1094 ssize_t index = mDisplayStates.indexOf(state);
1095 if (index < 0) {
1096 mDisplayStates.add(state);
1097 } else {
1098 mDisplayStates.editItemAt(static_cast<size_t>(index)).merge(state);
1099 }
1100 }
Robert Carr2c5f6d22017-09-26 12:30:35 -07001101
Marissa Wallc837b5e2018-10-12 10:04:44 -07001102 for (const auto& [listener, callbackInfo] : other.mListenerCallbacks) {
1103 auto& [callbackIds, surfaceControls] = callbackInfo;
1104 mListenerCallbacks[listener].callbackIds.insert(std::make_move_iterator(
1105 callbackIds.begin()),
1106 std::make_move_iterator(callbackIds.end()));
Valerie Hau9dab9732019-08-20 09:29:25 -07001107
Valerie Hau236eba32020-01-03 16:53:39 -08001108 mListenerCallbacks[listener].surfaceControls.insert(surfaceControls.begin(),
1109 surfaceControls.end());
1110
1111 auto& currentProcessCallbackInfo =
1112 mListenerCallbacks[TransactionCompletedListener::getIInstance()];
1113 currentProcessCallbackInfo.surfaceControls
1114 .insert(std::make_move_iterator(surfaceControls.begin()),
1115 std::make_move_iterator(surfaceControls.end()));
1116
1117 // register all surface controls for all callbackIds for this listener that is merging
1118 for (const auto& surfaceControl : currentProcessCallbackInfo.surfaceControls) {
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001119 mTransactionCompletedListener
1120 ->addSurfaceControlToCallbacks(surfaceControl,
1121 currentProcessCallbackInfo.callbackIds);
Valerie Hau236eba32020-01-03 16:53:39 -08001122 }
Marissa Wallc837b5e2018-10-12 10:04:44 -07001123 }
Marissa Wallc837b5e2018-10-12 10:04:44 -07001124
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00001125 for (const auto& cacheId : other.mUncacheBuffers) {
1126 mUncacheBuffers.push_back(cacheId);
1127 }
1128
chaviw273171b2018-12-26 11:46:30 -08001129 mInputWindowCommands.merge(other.mInputWindowCommands);
1130
Chavi Weingarten1ac2a922022-09-15 20:34:48 +00001131 mMayContainBuffer |= other.mMayContainBuffer;
Ady Abraham8cbd3072021-03-15 16:39:06 -07001132 mEarlyWakeupStart = mEarlyWakeupStart || other.mEarlyWakeupStart;
1133 mEarlyWakeupEnd = mEarlyWakeupEnd || other.mEarlyWakeupEnd;
Vishnu Nair277142c2021-01-05 18:35:29 -08001134 mApplyToken = other.mApplyToken;
Ady Abraham22c7b5c2020-09-22 19:33:40 -07001135
Huihong Luo3bdef862022-03-03 11:57:19 -08001136 mergeFrameTimelineInfo(mFrameTimelineInfo, other.mFrameTimelineInfo);
Ady Abraham22c7b5c2020-09-22 19:33:40 -07001137
Vishnu Nairfef244e2019-06-17 18:07:51 -07001138 other.clear();
Robert Carr2c5f6d22017-09-26 12:30:35 -07001139 return *this;
1140}
1141
Vishnu Nairfef244e2019-06-17 18:07:51 -07001142void SurfaceComposerClient::Transaction::clear() {
1143 mComposerStates.clear();
1144 mDisplayStates.clear();
1145 mListenerCallbacks.clear();
1146 mInputWindowCommands.clear();
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00001147 mUncacheBuffers.clear();
Chavi Weingarten1ac2a922022-09-15 20:34:48 +00001148 mMayContainBuffer = false;
Vishnu Nairfef244e2019-06-17 18:07:51 -07001149 mAnimation = false;
Ady Abraham8cbd3072021-03-15 16:39:06 -07001150 mEarlyWakeupStart = false;
1151 mEarlyWakeupEnd = false;
Ady Abrahamf0c56492020-12-17 18:04:15 -08001152 mDesiredPresentTime = 0;
1153 mIsAutoTimestamp = true;
Ady Abraham88930f92023-06-07 10:32:08 -07001154 mFrameTimelineInfo = {};
Vishnu Nair277142c2021-01-05 18:35:29 -08001155 mApplyToken = nullptr;
Pablo Gamito23780be2023-04-18 08:30:00 +00001156 mMergedTransactionIds.clear();
Vishnu Nairfef244e2019-06-17 18:07:51 -07001157}
1158
Pablo Gamito3e4e0be2022-05-27 17:26:24 +00001159uint64_t SurfaceComposerClient::Transaction::getId() {
1160 return mId;
1161}
1162
Pablo Gamito23780be2023-04-18 08:30:00 +00001163std::vector<uint64_t> SurfaceComposerClient::Transaction::getMergedTransactionIds() {
1164 return mMergedTransactionIds;
1165}
1166
Marissa Wall78b72202019-03-15 14:58:34 -07001167void SurfaceComposerClient::doUncacheBufferTransaction(uint64_t cacheId) {
1168 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
1169
Marissa Wall947d34e2019-03-29 14:03:53 -07001170 client_cache_t uncacheBuffer;
Marissa Wall78b72202019-03-15 14:58:34 -07001171 uncacheBuffer.token = BufferCache::getInstance().getToken();
Marissa Wall947d34e2019-03-29 14:03:53 -07001172 uncacheBuffer.id = cacheId;
Vishnu Nair40fff5c2022-11-04 02:46:28 +00001173 Vector<ComposerState> composerStates;
Patrick Williamsf65da8a2024-07-24 17:11:19 +00001174 Vector<DisplayState> displayStates;
1175 status_t status = sf->setTransactionState(FrameTimelineInfo{}, composerStates, displayStates,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00001176 ISurfaceComposer::eOneWay,
1177 Transaction::getDefaultApplyToken(), {}, systemTime(),
Pablo Gamito23780be2023-04-18 08:30:00 +00001178 true, {uncacheBuffer}, false, {}, generateId(), {});
Patrick Williams640b7292022-10-11 19:25:06 +00001179 if (status != NO_ERROR) {
1180 ALOGE_AND_TRACE("SurfaceComposerClient::doUncacheBufferTransaction - %s",
1181 strerror(-status));
1182 }
Marissa Wall78b72202019-03-15 14:58:34 -07001183}
1184
1185void SurfaceComposerClient::Transaction::cacheBuffers() {
Chavi Weingarten1ac2a922022-09-15 20:34:48 +00001186 if (!mMayContainBuffer) {
Marissa Wall78b72202019-03-15 14:58:34 -07001187 return;
1188 }
1189
1190 size_t count = 0;
Vishnu Nairf03652d2019-07-16 17:56:56 -07001191 for (auto& [handle, cs] : mComposerStates) {
Pablo Gamitodbc31672020-09-01 18:28:58 +00001192 layer_state_t* s = &(mComposerStates[handle].state);
Marissa Wall78b72202019-03-15 14:58:34 -07001193 if (!(s->what & layer_state_t::eBufferChanged)) {
1194 continue;
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001195 } else if (s->bufferData &&
1196 s->bufferData->flags.test(BufferData::BufferDataChange::cachedBufferChanged)) {
Robert Carr28037922020-04-08 10:57:07 -07001197 // If eBufferChanged and eCachedBufferChanged are both trued then that means
1198 // we already cached the buffer in a previous call to cacheBuffers, perhaps
1199 // from writeToParcel on a Transaction that was merged in to this one.
1200 continue;
Marissa Wall78b72202019-03-15 14:58:34 -07001201 }
1202
Marissa Wall00597242019-03-27 10:35:19 -07001203 // Don't try to cache a null buffer. Sending null buffers is cheap so we shouldn't waste
1204 // time trying to cache them.
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001205 if (!s->bufferData || !s->bufferData->buffer) {
Marissa Wall00597242019-03-27 10:35:19 -07001206 continue;
1207 }
1208
Marissa Wall78b72202019-03-15 14:58:34 -07001209 uint64_t cacheId = 0;
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001210 status_t ret = BufferCache::getInstance().getCacheId(s->bufferData->buffer, &cacheId);
Marissa Wall78b72202019-03-15 14:58:34 -07001211 if (ret == NO_ERROR) {
Robert Carre06ad2b2020-04-10 15:09:33 -07001212 // Cache-hit. Strip the buffer and send only the id.
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001213 s->bufferData->buffer = nullptr;
Marissa Wall78b72202019-03-15 14:58:34 -07001214 } else {
Robert Carre06ad2b2020-04-10 15:09:33 -07001215 // Cache-miss. Include the buffer and send the new cacheId.
Patrick Williams6c6dd3b2023-02-13 22:53:06 +00001216 std::optional<client_cache_t> uncacheBuffer;
1217 cacheId = BufferCache::getInstance().cache(s->bufferData->buffer, uncacheBuffer);
1218 if (uncacheBuffer) {
1219 mUncacheBuffers.push_back(*uncacheBuffer);
1220 }
Marissa Wall78b72202019-03-15 14:58:34 -07001221 }
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001222 s->bufferData->flags |= BufferData::BufferDataChange::cachedBufferChanged;
1223 s->bufferData->cachedBuffer.token = BufferCache::getInstance().getToken();
1224 s->bufferData->cachedBuffer.id = cacheId;
Marissa Wall78b72202019-03-15 14:58:34 -07001225
1226 // If we have more buffers than the size of the cache, we should stop caching so we don't
1227 // evict other buffers in this transaction
1228 count++;
1229 if (count >= BUFFER_CACHE_MAX_SIZE) {
1230 break;
1231 }
1232 }
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001233}
1234
Vishnu Nair9402bb02022-09-28 16:45:06 -07001235class SyncCallback {
1236public:
Vishnu Nair4e04c3a2022-12-09 20:48:00 +00001237 static auto getCallback(std::shared_ptr<SyncCallback>& callbackContext) {
1238 return [callbackContext](void* /* unused context */, nsecs_t /* latchTime */,
1239 const sp<Fence>& /* presentFence */,
1240 const std::vector<SurfaceControlStats>& /* stats */) {
1241 if (!callbackContext) {
1242 ALOGE("failed to get callback context for SyncCallback");
1243 return;
1244 }
1245 LOG_ALWAYS_FATAL_IF(sem_post(&callbackContext->mSemaphore), "sem_post failed");
1246 };
Vishnu Nair9402bb02022-09-28 16:45:06 -07001247 }
1248 ~SyncCallback() {
1249 if (mInitialized) {
1250 LOG_ALWAYS_FATAL_IF(sem_destroy(&mSemaphore), "sem_destroy failed");
1251 }
1252 }
1253 void init() {
1254 LOG_ALWAYS_FATAL_IF(clock_gettime(CLOCK_MONOTONIC, &mTimeoutTimespec) == -1,
1255 "clock_gettime() fail! in SyncCallback::init");
1256 mTimeoutTimespec.tv_sec += 4;
1257 LOG_ALWAYS_FATAL_IF(sem_init(&mSemaphore, 0, 0), "sem_init failed");
1258 mInitialized = true;
1259 }
1260 void wait() {
1261 int result = sem_clockwait(&mSemaphore, CLOCK_MONOTONIC, &mTimeoutTimespec);
1262 if (result && errno != ETIMEDOUT && errno != EINTR) {
1263 LOG_ALWAYS_FATAL("sem_clockwait failed(%d)", errno);
1264 } else if (errno == ETIMEDOUT) {
1265 ALOGW("Sync transaction timed out waiting for commit callback.");
1266 }
1267 }
1268 void* getContext() { return static_cast<void*>(this); }
1269
1270private:
1271 sem_t mSemaphore;
1272 bool mInitialized = false;
1273 timespec mTimeoutTimespec;
1274};
1275
Robert Carr79dc06a2022-02-22 15:28:59 -08001276status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay) {
Robert Carr4cdc58f2017-08-23 14:22:20 -07001277 if (mStatus != NO_ERROR) {
1278 return mStatus;
1279 }
1280
Vishnu Nair4e04c3a2022-12-09 20:48:00 +00001281 std::shared_ptr<SyncCallback> syncCallback = std::make_shared<SyncCallback>();
Vishnu Nair9402bb02022-09-28 16:45:06 -07001282 if (synchronous) {
Vishnu Nair4e04c3a2022-12-09 20:48:00 +00001283 syncCallback->init();
1284 addTransactionCommittedCallback(SyncCallback::getCallback(syncCallback),
1285 /*callbackContext=*/nullptr);
Vishnu Nair9402bb02022-09-28 16:45:06 -07001286 }
Robert Carr4cdc58f2017-08-23 14:22:20 -07001287
Valerie Hau9dab9732019-08-20 09:29:25 -07001288 bool hasListenerCallbacks = !mListenerCallbacks.empty();
Marissa Wall3dad52d2019-03-22 14:03:19 -07001289 std::vector<ListenerCallbacks> listenerCallbacks;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001290 // For every listener with registered callbacks
1291 for (const auto& [listener, callbackInfo] : mListenerCallbacks) {
1292 auto& [callbackIds, surfaceControls] = callbackInfo;
1293 if (callbackIds.empty()) {
1294 continue;
1295 }
1296
Valerie Hau9dab9732019-08-20 09:29:25 -07001297 if (surfaceControls.empty()) {
1298 listenerCallbacks.emplace_back(IInterface::asBinder(listener), std::move(callbackIds));
1299 } else {
1300 // If the listener has any SurfaceControls set on this Transaction update the surface
1301 // state
1302 for (const auto& surfaceControl : surfaceControls) {
1303 layer_state_t* s = getLayerState(surfaceControl);
1304 if (!s) {
1305 ALOGE("failed to get layer state");
1306 continue;
1307 }
1308 std::vector<CallbackId> callbacks(callbackIds.begin(), callbackIds.end());
1309 s->what |= layer_state_t::eHasListenerCallbacksChanged;
1310 s->listeners.emplace_back(IInterface::asBinder(listener), callbacks);
Marissa Wallc837b5e2018-10-12 10:04:44 -07001311 }
Marissa Wallc837b5e2018-10-12 10:04:44 -07001312 }
1313 }
Valerie Hau9dab9732019-08-20 09:29:25 -07001314
Marissa Wall78b72202019-03-15 14:58:34 -07001315 cacheBuffers();
1316
Robert Carr4cdc58f2017-08-23 14:22:20 -07001317 Vector<ComposerState> composerStates;
1318 Vector<DisplayState> displayStates;
1319 uint32_t flags = 0;
1320
Vishnu Nair9402bb02022-09-28 16:45:06 -07001321 for (auto const& kv : mComposerStates) {
chaviw8e3fe5d2018-02-22 10:55:42 -08001322 composerStates.add(kv.second);
1323 }
1324
Adithya Srinivasand3efcb32020-10-20 18:08:22 -07001325 displayStates = std::move(mDisplayStates);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001326
Robert Carr4cdc58f2017-08-23 14:22:20 -07001327 if (mAnimation) {
1328 flags |= ISurfaceComposer::eAnimation;
1329 }
Robert Carr79dc06a2022-02-22 15:28:59 -08001330 if (oneWay) {
Vishnu Nair2709efe2022-09-28 17:17:08 -07001331 if (synchronous) {
1332 ALOGE("Transaction attempted to set synchronous and one way at the same time"
1333 " this is an invalid request. Synchronous will win for safety");
1334 } else {
1335 flags |= ISurfaceComposer::eOneWay;
1336 }
Robert Carr79dc06a2022-02-22 15:28:59 -08001337 }
Robert Carr4cdc58f2017-08-23 14:22:20 -07001338
Ady Abraham8cbd3072021-03-15 16:39:06 -07001339 // If both mEarlyWakeupStart and mEarlyWakeupEnd are set
Ady Abrahambf1349c2020-06-12 14:26:18 -07001340 // it is equivalent for none
Ady Abraham8cbd3072021-03-15 16:39:06 -07001341 if (mEarlyWakeupStart && !mEarlyWakeupEnd) {
1342 flags |= ISurfaceComposer::eEarlyWakeupStart;
Ady Abrahambf1349c2020-06-12 14:26:18 -07001343 }
Ady Abraham8cbd3072021-03-15 16:39:06 -07001344 if (mEarlyWakeupEnd && !mEarlyWakeupStart) {
1345 flags |= ISurfaceComposer::eEarlyWakeupEnd;
Ady Abrahambf1349c2020-06-12 14:26:18 -07001346 }
1347
Patrick Williams84541d12023-09-29 11:00:23 -05001348 sp<IBinder> applyToken = mApplyToken ? mApplyToken : getDefaultApplyToken();
Vishnu Nair277142c2021-01-05 18:35:29 -08001349
Vishnu Nair9402bb02022-09-28 16:45:06 -07001350 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
Patrick Williamsa419faa2024-10-29 16:50:27 -05001351 status_t binderStatus =
1352 sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags,
1353 applyToken, mInputWindowCommands, mDesiredPresentTime,
1354 mIsAutoTimestamp, mUncacheBuffers, hasListenerCallbacks,
1355 listenerCallbacks, mId, mMergedTransactionIds);
Adithya Srinivasand3efcb32020-10-20 18:08:22 -07001356 mId = generateId();
1357
1358 // Clear the current states and flags
1359 clear();
1360
Patrick Williamsa419faa2024-10-29 16:50:27 -05001361 if (synchronous && binderStatus == OK) {
Vishnu Nair4e04c3a2022-12-09 20:48:00 +00001362 syncCallback->wait();
Vishnu Nair9402bb02022-09-28 16:45:06 -07001363 }
1364
Robert Carr4cdc58f2017-08-23 14:22:20 -07001365 mStatus = NO_ERROR;
Patrick Williamsa419faa2024-10-29 16:50:27 -05001366 return binderStatus;
Mathias Agopiane57f2922012-08-09 16:29:12 -07001367}
1368
Vishnu Nair80da86b2022-08-11 16:32:58 -07001369sp<IBinder> SurfaceComposerClient::Transaction::sApplyToken = new BBinder();
1370
Patrick Williams84541d12023-09-29 11:00:23 -05001371std::mutex SurfaceComposerClient::Transaction::sApplyTokenMutex;
1372
Vishnu Nair80da86b2022-08-11 16:32:58 -07001373sp<IBinder> SurfaceComposerClient::Transaction::getDefaultApplyToken() {
Patrick Williams84541d12023-09-29 11:00:23 -05001374 std::scoped_lock lock{sApplyTokenMutex};
Vishnu Nair80da86b2022-08-11 16:32:58 -07001375 return sApplyToken;
1376}
1377
1378void SurfaceComposerClient::Transaction::setDefaultApplyToken(sp<IBinder> applyToken) {
Patrick Williams84541d12023-09-29 11:00:23 -05001379 std::scoped_lock lock{sApplyTokenMutex};
Patrick Williamsa419faa2024-10-29 16:50:27 -05001380 sApplyToken = std::move(applyToken);
Vishnu Nair80da86b2022-08-11 16:32:58 -07001381}
Pascal Muetschardb39918f2023-01-27 11:36:11 +01001382
1383status_t SurfaceComposerClient::Transaction::sendSurfaceFlushJankDataTransaction(
1384 const sp<SurfaceControl>& sc) {
1385 Transaction t;
1386 layer_state_t* s = t.getLayerState(sc);
1387 if (!s) {
1388 return BAD_INDEX;
1389 }
1390
1391 s->what |= layer_state_t::eFlushJankData;
1392 t.registerSurfaceControlForCallback(sc);
1393 return t.apply(/*sync=*/false, /* oneWay=*/true);
1394}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001395// ---------------------------------------------------------------------------
1396
Alan Dingd53801c2024-05-08 16:45:29 -07001397sp<IBinder> SurfaceComposerClient::createVirtualDisplay(const std::string& displayName,
1398 bool isSecure, const std::string& uniqueId,
1399 float requestedRefreshRate) {
Huihong Luo07e72362022-02-14 14:26:04 -08001400 sp<IBinder> display = nullptr;
Alan Dingd53801c2024-05-08 16:45:29 -07001401 binder::Status status =
1402 ComposerServiceAIDL::getComposerService()->createVirtualDisplay(displayName, isSecure,
1403 uniqueId,
1404 requestedRefreshRate,
1405 &display);
Huihong Luo07e72362022-02-14 14:26:04 -08001406 return status.isOk() ? display : nullptr;
Mathias Agopiane57f2922012-08-09 16:29:12 -07001407}
1408
Alan Dingd53801c2024-05-08 16:45:29 -07001409status_t SurfaceComposerClient::destroyVirtualDisplay(const sp<IBinder>& displayToken) {
1410 return ComposerServiceAIDL::getComposerService()
1411 ->destroyVirtualDisplay(displayToken)
1412 .transactionError();
Jesse Hall6c913be2013-08-08 12:15:49 -07001413}
1414
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001415std::vector<PhysicalDisplayId> SurfaceComposerClient::getPhysicalDisplayIds() {
Huihong Luo07e72362022-02-14 14:26:04 -08001416 std::vector<int64_t> displayIds;
1417 std::vector<PhysicalDisplayId> physicalDisplayIds;
1418 binder::Status status =
1419 ComposerServiceAIDL::getComposerService()->getPhysicalDisplayIds(&displayIds);
1420 if (status.isOk()) {
1421 physicalDisplayIds.reserve(displayIds.size());
1422 for (auto item : displayIds) {
1423 auto id = DisplayId::fromValue<PhysicalDisplayId>(static_cast<uint64_t>(item));
1424 physicalDisplayIds.push_back(*id);
1425 }
1426 }
1427 return physicalDisplayIds;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001428}
1429
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001430sp<IBinder> SurfaceComposerClient::getPhysicalDisplayToken(PhysicalDisplayId displayId) {
Huihong Luo07e72362022-02-14 14:26:04 -08001431 sp<IBinder> display = nullptr;
1432 binder::Status status =
1433 ComposerServiceAIDL::getComposerService()->getPhysicalDisplayToken(displayId.value,
1434 &display);
1435 return status.isOk() ? display : nullptr;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -08001436}
1437
Patrick Williams090ad062023-08-08 12:30:10 -05001438std::optional<gui::StalledTransactionInfo> SurfaceComposerClient::getStalledTransactionInfo(
1439 pid_t pid) {
1440 std::optional<gui::StalledTransactionInfo> result;
1441 ComposerServiceAIDL::getComposerService()->getStalledTransactionInfo(pid, &result);
1442 return result;
1443}
1444
Robert Carr4cdc58f2017-08-23 14:22:20 -07001445void SurfaceComposerClient::Transaction::setAnimationTransaction() {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001446 mAnimation = true;
1447}
1448
Ady Abraham8cbd3072021-03-15 16:39:06 -07001449void SurfaceComposerClient::Transaction::setEarlyWakeupStart() {
1450 mEarlyWakeupStart = true;
Dan Stoza84d619e2018-03-28 17:07:36 -07001451}
1452
Ady Abraham8cbd3072021-03-15 16:39:06 -07001453void SurfaceComposerClient::Transaction::setEarlyWakeupEnd() {
1454 mEarlyWakeupEnd = true;
Ady Abrahambf1349c2020-06-12 14:26:18 -07001455}
1456
Pablo Gamitodbc31672020-09-01 18:28:58 +00001457layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<SurfaceControl>& sc) {
Robert Carr5b3b9142021-02-22 12:27:32 -08001458 auto handle = sc->getLayerStateHandle();
Pablo Gamitodbc31672020-09-01 18:28:58 +00001459
Vishnu Nairf03652d2019-07-16 17:56:56 -07001460 if (mComposerStates.count(handle) == 0) {
Mathias Agopian698c0872011-06-28 19:09:31 -07001461 // we don't have it, add an initialized layer_state to our list
chaviw8e3fe5d2018-02-22 10:55:42 -08001462 ComposerState s;
Pablo Gamitodbc31672020-09-01 18:28:58 +00001463
Vishnu Nairf03652d2019-07-16 17:56:56 -07001464 s.state.surface = handle;
Pablo Gamitodbc31672020-09-01 18:28:58 +00001465 s.state.layerId = sc->getLayerId();
1466
Vishnu Nairf03652d2019-07-16 17:56:56 -07001467 mComposerStates[handle] = s;
Mathias Agopian698c0872011-06-28 19:09:31 -07001468 }
1469
Vishnu Nairf03652d2019-07-16 17:56:56 -07001470 return &(mComposerStates[handle].state);
Mathias Agopian698c0872011-06-28 19:09:31 -07001471}
1472
Marissa Wallc837b5e2018-10-12 10:04:44 -07001473void SurfaceComposerClient::Transaction::registerSurfaceControlForCallback(
1474 const sp<SurfaceControl>& sc) {
Marissa Wall80d94ad2019-01-18 16:04:36 -08001475 auto& callbackInfo = mListenerCallbacks[TransactionCompletedListener::getIInstance()];
1476 callbackInfo.surfaceControls.insert(sc);
1477
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001478 mTransactionCompletedListener->addSurfaceControlToCallbacks(sc, callbackInfo.callbackIds);
Marissa Wallc837b5e2018-10-12 10:04:44 -07001479}
1480
Robert Carr4cdc58f2017-08-23 14:22:20 -07001481SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setPosition(
1482 const sp<SurfaceControl>& sc, float x, float y) {
chaviw763ef572018-02-22 16:04:57 -08001483 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001484 if (!s) {
1485 mStatus = BAD_INDEX;
1486 return *this;
1487 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001488 s->what |= layer_state_t::ePositionChanged;
Mathias Agopian698c0872011-06-28 19:09:31 -07001489 s->x = x;
1490 s->y = y;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001491
1492 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001493 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001494}
1495
Robert Carr4cdc58f2017-08-23 14:22:20 -07001496SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::show(
1497 const sp<SurfaceControl>& sc) {
1498 return setFlags(sc, 0, layer_state_t::eLayerHidden);
1499}
1500
1501SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::hide(
1502 const sp<SurfaceControl>& sc) {
1503 return setFlags(sc, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden);
1504}
1505
Robert Carr4cdc58f2017-08-23 14:22:20 -07001506SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLayer(
1507 const sp<SurfaceControl>& sc, int32_t z) {
chaviw763ef572018-02-22 16:04:57 -08001508 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001509 if (!s) {
1510 mStatus = BAD_INDEX;
1511 return *this;
1512 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001513 s->what |= layer_state_t::eLayerChanged;
chaviw32377582019-05-13 11:15:19 -07001514 s->what &= ~layer_state_t::eRelativeLayerChanged;
Mathias Agopian698c0872011-06-28 19:09:31 -07001515 s->z = z;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001516
1517 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001518 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001519}
1520
Pablo Gamito11dcc222020-09-12 15:49:39 +00001521SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setRelativeLayer(
1522 const sp<SurfaceControl>& sc, const sp<SurfaceControl>& relativeTo, int32_t z) {
chaviw763ef572018-02-22 16:04:57 -08001523 layer_state_t* s = getLayerState(sc);
Robert Carrdb66e622017-04-10 16:55:57 -07001524 if (!s) {
Robert Carr4cdc58f2017-08-23 14:22:20 -07001525 mStatus = BAD_INDEX;
Robert Carr30c8d902019-04-04 13:12:49 -07001526 return *this;
Robert Carrdb66e622017-04-10 16:55:57 -07001527 }
1528 s->what |= layer_state_t::eRelativeLayerChanged;
chaviw32377582019-05-13 11:15:19 -07001529 s->what &= ~layer_state_t::eLayerChanged;
Pablo Gamito11dcc222020-09-12 15:49:39 +00001530 s->relativeLayerSurfaceControl = relativeTo;
Robert Carrdb66e622017-04-10 16:55:57 -07001531 s->z = z;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001532
1533 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001534 return *this;
Robert Carrdb66e622017-04-10 16:55:57 -07001535}
1536
Robert Carr4cdc58f2017-08-23 14:22:20 -07001537SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFlags(
1538 const sp<SurfaceControl>& sc, uint32_t flags,
Mathias Agopian698c0872011-06-28 19:09:31 -07001539 uint32_t mask) {
chaviw763ef572018-02-22 16:04:57 -08001540 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001541 if (!s) {
1542 mStatus = BAD_INDEX;
1543 return *this;
1544 }
Melody Hsu117556e2024-10-03 21:58:56 +00001545 s->what |= layer_state_t::eFlagsChanged;
Mathias Agopian698c0872011-06-28 19:09:31 -07001546 s->flags &= ~mask;
1547 s->flags |= (flags & mask);
1548 s->mask |= mask;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001549
1550 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001551 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001552}
1553
Robert Carr4cdc58f2017-08-23 14:22:20 -07001554SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTransparentRegionHint(
1555 const sp<SurfaceControl>& sc,
Mathias Agopian698c0872011-06-28 19:09:31 -07001556 const Region& transparentRegion) {
chaviw763ef572018-02-22 16:04:57 -08001557 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001558 if (!s) {
1559 mStatus = BAD_INDEX;
1560 return *this;
1561 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001562 s->what |= layer_state_t::eTransparentRegionChanged;
Mathias Agopian698c0872011-06-28 19:09:31 -07001563 s->transparentRegion = transparentRegion;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001564
1565 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001566 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001567}
1568
Sally Qi421ffb02022-03-21 19:41:33 -07001569SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDimmingEnabled(
1570 const sp<SurfaceControl>& sc, bool dimmingEnabled) {
1571 layer_state_t* s = getLayerState(sc);
1572 if (!s) {
1573 mStatus = BAD_INDEX;
1574 return *this;
1575 }
1576 s->what |= layer_state_t::eDimmingEnabledChanged;
1577 s->dimmingEnabled = dimmingEnabled;
1578
1579 registerSurfaceControlForCallback(sc);
1580 return *this;
1581}
1582
Robert Carr4cdc58f2017-08-23 14:22:20 -07001583SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setAlpha(
1584 const sp<SurfaceControl>& sc, float alpha) {
chaviw763ef572018-02-22 16:04:57 -08001585 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001586 if (!s) {
1587 mStatus = BAD_INDEX;
1588 return *this;
1589 }
Ady Abrahamff930b42022-08-05 19:04:16 +00001590 if (alpha < 0.0f || alpha > 1.0f) {
Ady Abraham24d0b2a2022-08-11 16:27:34 -07001591 ALOGE("SurfaceComposerClient::Transaction::setAlpha: invalid alpha %f, clamping", alpha);
Ady Abrahamff930b42022-08-05 19:04:16 +00001592 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001593 s->what |= layer_state_t::eAlphaChanged;
Vishnu Nairbbceb462022-10-10 04:52:13 +00001594 s->color.a = std::clamp(alpha, 0.f, 1.f);
Marissa Wallc837b5e2018-10-12 10:04:44 -07001595
1596 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001597 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001598}
1599
Robert Carr4cdc58f2017-08-23 14:22:20 -07001600SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLayerStack(
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001601 const sp<SurfaceControl>& sc, ui::LayerStack layerStack) {
chaviw763ef572018-02-22 16:04:57 -08001602 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001603 if (!s) {
1604 mStatus = BAD_INDEX;
1605 return *this;
1606 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001607 s->what |= layer_state_t::eLayerStackChanged;
Mathias Agopian87855782012-07-24 21:41:09 -07001608 s->layerStack = layerStack;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001609
1610 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001611 return *this;
Mathias Agopian87855782012-07-24 21:41:09 -07001612}
1613
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001614SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setMetadata(
Garfield Tan01a56132019-08-05 16:44:21 -07001615 const sp<SurfaceControl>& sc, uint32_t key, const Parcel& p) {
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001616 layer_state_t* s = getLayerState(sc);
1617 if (!s) {
1618 mStatus = BAD_INDEX;
1619 return *this;
1620 }
1621 s->what |= layer_state_t::eMetadataChanged;
Garfield Tan01a56132019-08-05 16:44:21 -07001622
1623 s->metadata.mMap[key] = {p.data(), p.data() + p.dataSize()};
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001624
1625 registerSurfaceControlForCallback(sc);
1626 return *this;
1627}
1628
Robert Carr4cdc58f2017-08-23 14:22:20 -07001629SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setMatrix(
1630 const sp<SurfaceControl>& sc, float dsdx, float dtdx,
Robert Carrcb6e1e32017-02-21 19:48:26 -08001631 float dtdy, float dsdy) {
chaviw763ef572018-02-22 16:04:57 -08001632 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001633 if (!s) {
1634 mStatus = BAD_INDEX;
1635 return *this;
1636 }
Mathias Agopian3165cc22012-08-08 19:42:09 -07001637 s->what |= layer_state_t::eMatrixChanged;
Mathias Agopian698c0872011-06-28 19:09:31 -07001638 layer_state_t::matrix22_t matrix;
1639 matrix.dsdx = dsdx;
1640 matrix.dtdx = dtdx;
1641 matrix.dsdy = dsdy;
1642 matrix.dtdy = dtdy;
1643 s->matrix = matrix;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001644
1645 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001646 return *this;
Mathias Agopian698c0872011-06-28 19:09:31 -07001647}
1648
chaviw25714502021-02-11 10:01:08 -08001649SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(
Robert Carr4cdc58f2017-08-23 14:22:20 -07001650 const sp<SurfaceControl>& sc, const Rect& crop) {
Vishnu Naira9123c82024-10-03 03:56:44 +00001651 return setCrop(sc, crop.toFloatRect());
1652}
1653
1654SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(
1655 const sp<SurfaceControl>& sc, const FloatRect& crop) {
chaviw763ef572018-02-22 16:04:57 -08001656 layer_state_t* s = getLayerState(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001657 if (!s) {
1658 mStatus = BAD_INDEX;
1659 return *this;
1660 }
chaviw25714502021-02-11 10:01:08 -08001661 s->what |= layer_state_t::eCropChanged;
1662 s->crop = crop;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001663
1664 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001665 return *this;
Jamie Gennisf15a83f2012-05-10 20:43:55 -07001666}
1667
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001668SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCornerRadius(
1669 const sp<SurfaceControl>& sc, float cornerRadius) {
1670 layer_state_t* s = getLayerState(sc);
1671 if (!s) {
1672 mStatus = BAD_INDEX;
1673 return *this;
1674 }
1675 s->what |= layer_state_t::eCornerRadiusChanged;
1676 s->cornerRadius = cornerRadius;
1677 return *this;
1678}
1679
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001680SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBackgroundBlurRadius(
1681 const sp<SurfaceControl>& sc, int backgroundBlurRadius) {
1682 layer_state_t* s = getLayerState(sc);
1683 if (!s) {
1684 mStatus = BAD_INDEX;
1685 return *this;
1686 }
1687 s->what |= layer_state_t::eBackgroundBlurRadiusChanged;
1688 s->backgroundBlurRadius = backgroundBlurRadius;
1689 return *this;
1690}
1691
Lucas Dupinc3800b82020-10-02 16:24:48 -07001692SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBlurRegions(
1693 const sp<SurfaceControl>& sc, const std::vector<BlurRegion>& blurRegions) {
1694 layer_state_t* s = getLayerState(sc);
1695 if (!s) {
1696 mStatus = BAD_INDEX;
1697 return *this;
1698 }
1699 s->what |= layer_state_t::eBlurRegionsChanged;
1700 s->blurRegions = blurRegions;
1701 return *this;
1702}
1703
Robert Carr4cdc58f2017-08-23 14:22:20 -07001704SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::reparent(
Pablo Gamito11dcc222020-09-12 15:49:39 +00001705 const sp<SurfaceControl>& sc, const sp<SurfaceControl>& newParent) {
chaviw763ef572018-02-22 16:04:57 -08001706 layer_state_t* s = getLayerState(sc);
chaviw06178942017-07-27 10:25:59 -07001707 if (!s) {
Robert Carr4cdc58f2017-08-23 14:22:20 -07001708 mStatus = BAD_INDEX;
1709 return *this;
chaviw06178942017-07-27 10:25:59 -07001710 }
Robert Carr5b3b9142021-02-22 12:27:32 -08001711 if (SurfaceControl::isSameSurface(sc, newParent)) {
1712 return *this;
1713 }
chaviwf1961f72017-09-18 16:41:07 -07001714 s->what |= layer_state_t::eReparent;
Robert Carr5b3b9142021-02-22 12:27:32 -08001715 s->parentSurfaceControlForChild = newParent ? newParent->getParentingLayer() : nullptr;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001716
1717 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001718 return *this;
chaviw06178942017-07-27 10:25:59 -07001719}
1720
Robert Carr4cdc58f2017-08-23 14:22:20 -07001721SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColor(
1722 const sp<SurfaceControl>& sc,
1723 const half3& color) {
chaviw763ef572018-02-22 16:04:57 -08001724 layer_state_t* s = getLayerState(sc);
Robert Carr9524cb32017-02-13 11:32:32 -08001725 if (!s) {
Robert Carr4cdc58f2017-08-23 14:22:20 -07001726 mStatus = BAD_INDEX;
1727 return *this;
1728 }
1729 s->what |= layer_state_t::eColorChanged;
Vishnu Nairbbceb462022-10-10 04:52:13 +00001730 s->color.rgb = color;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001731
1732 registerSurfaceControlForCallback(sc);
Robert Carr4cdc58f2017-08-23 14:22:20 -07001733 return *this;
1734}
1735
Valerie Haudd0b7572019-01-29 14:59:27 -08001736SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBackgroundColor(
1737 const sp<SurfaceControl>& sc, const half3& color, float alpha, ui::Dataspace dataspace) {
Valerie Haued54efa2019-01-11 20:03:14 -08001738 layer_state_t* s = getLayerState(sc);
1739 if (!s) {
1740 mStatus = BAD_INDEX;
1741 return *this;
1742 }
1743
Valerie Haudd0b7572019-01-29 14:59:27 -08001744 s->what |= layer_state_t::eBackgroundColorChanged;
Vishnu Naird47bcee2023-02-24 18:08:51 +00001745 s->bgColor.rgb = color;
1746 s->bgColor.a = alpha;
Valerie Haudd0b7572019-01-29 14:59:27 -08001747 s->bgColorDataspace = dataspace;
Valerie Haued54efa2019-01-11 20:03:14 -08001748
1749 registerSurfaceControlForCallback(sc);
1750 return *this;
1751}
1752
Marissa Wall61c58622018-07-18 10:12:20 -07001753SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTransform(
1754 const sp<SurfaceControl>& sc, uint32_t transform) {
1755 layer_state_t* s = getLayerState(sc);
1756 if (!s) {
1757 mStatus = BAD_INDEX;
1758 return *this;
1759 }
Vishnu Nairbbceb462022-10-10 04:52:13 +00001760 s->what |= layer_state_t::eBufferTransformChanged;
1761 s->bufferTransform = transform;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001762
1763 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07001764 return *this;
1765}
1766
1767SurfaceComposerClient::Transaction&
1768SurfaceComposerClient::Transaction::setTransformToDisplayInverse(const sp<SurfaceControl>& sc,
1769 bool transformToDisplayInverse) {
1770 layer_state_t* s = getLayerState(sc);
1771 if (!s) {
1772 mStatus = BAD_INDEX;
1773 return *this;
1774 }
1775 s->what |= layer_state_t::eTransformToDisplayInverseChanged;
1776 s->transformToDisplayInverse = transformToDisplayInverse;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001777
1778 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07001779 return *this;
1780}
1781
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001782std::shared_ptr<BufferData> SurfaceComposerClient::Transaction::getAndClearBuffer(
chaviw0acd33a2021-11-02 11:55:37 -05001783 const sp<SurfaceControl>& sc) {
1784 layer_state_t* s = getLayerState(sc);
1785 if (!s) {
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001786 return nullptr;
chaviw0acd33a2021-11-02 11:55:37 -05001787 }
1788 if (!(s->what & layer_state_t::eBufferChanged)) {
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001789 return nullptr;
chaviw0acd33a2021-11-02 11:55:37 -05001790 }
1791
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001792 std::shared_ptr<BufferData> bufferData = std::move(s->bufferData);
chaviw0acd33a2021-11-02 11:55:37 -05001793
Vishnu Naira74ba0f2024-04-16 11:25:06 -07001794 mTransactionCompletedListener->removeReleaseBufferCallback(
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001795 bufferData->generateReleaseCallbackId());
chaviw0acd33a2021-11-02 11:55:37 -05001796 s->what &= ~layer_state_t::eBufferChanged;
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001797 s->bufferData = nullptr;
chaviw0acd33a2021-11-02 11:55:37 -05001798
chaviw0acd33a2021-11-02 11:55:37 -05001799 return bufferData;
1800}
1801
Robert Carr79dc06a2022-02-22 15:28:59 -08001802SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBufferHasBarrier(
1803 const sp<SurfaceControl>& sc, uint64_t barrierFrameNumber) {
1804 layer_state_t* s = getLayerState(sc);
1805 if (!s) {
1806 mStatus = BAD_INDEX;
1807 return *this;
1808 }
1809 s->bufferData->hasBarrier = true;
1810 s->bufferData->barrierFrameNumber = barrierFrameNumber;
1811 return *this;
1812}
1813
Marissa Wall61c58622018-07-18 10:12:20 -07001814SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBuffer(
chaviwba4320c2021-09-15 15:20:53 -05001815 const sp<SurfaceControl>& sc, const sp<GraphicBuffer>& buffer,
John Reck57f748c2022-03-17 17:23:49 -04001816 const std::optional<sp<Fence>>& fence, const std::optional<uint64_t>& optFrameNumber,
Nergi Rahardi39f510f2024-05-23 15:16:54 +09001817 uint32_t producerId, ReleaseBufferCallback callback, nsecs_t dequeueTime) {
Marissa Wall61c58622018-07-18 10:12:20 -07001818 layer_state_t* s = getLayerState(sc);
1819 if (!s) {
1820 mStatus = BAD_INDEX;
1821 return *this;
1822 }
chaviw69058fb2021-09-27 09:37:30 -05001823
1824 releaseBufferIfOverwriting(*s);
1825
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001826 std::shared_ptr<BufferData> bufferData = std::make_shared<BufferData>();
1827 bufferData->buffer = buffer;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001828 if (buffer) {
1829 uint64_t frameNumber = sc->resolveFrameNumber(optFrameNumber);
1830 bufferData->frameNumber = frameNumber;
1831 bufferData->producerId = producerId;
1832 bufferData->flags |= BufferData::BufferDataChange::frameNumberChanged;
Nergi Rahardi39f510f2024-05-23 15:16:54 +09001833 bufferData->dequeueTime = dequeueTime;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001834 if (fence) {
1835 bufferData->acquireFence = *fence;
1836 bufferData->flags |= BufferData::BufferDataChange::fenceChanged;
1837 }
Vishnu Naira74ba0f2024-04-16 11:25:06 -07001838 bufferData->releaseBufferEndpoint = IInterface::asBinder(mTransactionCompletedListener);
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001839 setReleaseBufferCallback(bufferData.get(), callback);
chaviwba4320c2021-09-15 15:20:53 -05001840 }
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001841
Ady Abrahamf0c56492020-12-17 18:04:15 -08001842 if (mIsAutoTimestamp) {
1843 mDesiredPresentTime = systemTime();
1844 }
chaviwba4320c2021-09-15 15:20:53 -05001845 s->what |= layer_state_t::eBufferChanged;
Vishnu Nair9f0835e2022-01-07 09:33:19 -08001846 s->bufferData = std::move(bufferData);
Marissa Wallebc2c052019-01-16 19:16:55 -08001847 registerSurfaceControlForCallback(sc);
Marissa Wall78b72202019-03-15 14:58:34 -07001848
chaviw1a227f02022-04-25 16:23:44 -05001849 // With the current infrastructure, a release callback will not be invoked if there's no
1850 // transaction callback in the case when a buffer is latched and not released early. This is
1851 // because the legacy implementation didn't have a release callback and sent releases in the
1852 // transaction callback. Because of this, we need to make sure to have a transaction callback
1853 // set up when a buffer is sent in a transaction to ensure the caller gets the release
1854 // callback, regardless if they set up a transaction callback.
1855 //
1856 // TODO (b/230380821): Remove when release callbacks are separated from transaction callbacks
1857 addTransactionCompletedCallback([](void*, nsecs_t, const sp<Fence>&,
1858 const std::vector<SurfaceControlStats>&) {},
1859 nullptr);
1860
Chavi Weingarten1ac2a922022-09-15 20:34:48 +00001861 mMayContainBuffer = true;
Marissa Wallebc2c052019-01-16 19:16:55 -08001862 return *this;
1863}
1864
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001865SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::unsetBuffer(
1866 const sp<SurfaceControl>& sc) {
1867 layer_state_t* s = getLayerState(sc);
1868 if (!s) {
1869 mStatus = BAD_INDEX;
1870 return *this;
1871 }
1872
1873 if (!(s->what & layer_state_t::eBufferChanged)) {
1874 return *this;
1875 }
1876
1877 releaseBufferIfOverwriting(*s);
1878
1879 s->what &= ~layer_state_t::eBufferChanged;
1880 s->bufferData = nullptr;
1881 return *this;
1882}
1883
chaviwba4320c2021-09-15 15:20:53 -05001884void SurfaceComposerClient::Transaction::setReleaseBufferCallback(BufferData* bufferData,
Vishnu Nair1506b182021-02-22 14:35:15 -08001885 ReleaseBufferCallback callback) {
1886 if (!callback) {
1887 return;
1888 }
1889
chaviwba4320c2021-09-15 15:20:53 -05001890 if (!bufferData->buffer) {
Vishnu Nair1506b182021-02-22 14:35:15 -08001891 ALOGW("Transaction::setReleaseBufferCallback"
1892 "ignored trying to set a callback on a null buffer.");
1893 return;
1894 }
1895
Vishnu Naira74ba0f2024-04-16 11:25:06 -07001896 bufferData->releaseBufferListener =
1897 static_cast<sp<ITransactionCompletedListener>>(mTransactionCompletedListener);
1898 mTransactionCompletedListener->setReleaseBufferCallback(bufferData->generateReleaseCallbackId(),
1899 callback);
Vishnu Nair1506b182021-02-22 14:35:15 -08001900}
1901
Marissa Wall61c58622018-07-18 10:12:20 -07001902SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDataspace(
1903 const sp<SurfaceControl>& sc, ui::Dataspace dataspace) {
1904 layer_state_t* s = getLayerState(sc);
1905 if (!s) {
1906 mStatus = BAD_INDEX;
1907 return *this;
1908 }
1909 s->what |= layer_state_t::eDataspaceChanged;
1910 s->dataspace = dataspace;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001911
1912 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07001913 return *this;
1914}
1915
John Reck68796592023-01-25 13:47:12 -05001916SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setExtendedRangeBrightness(
1917 const sp<SurfaceControl>& sc, float currentBufferRatio, float desiredRatio) {
1918 layer_state_t* s = getLayerState(sc);
1919 if (!s) {
1920 mStatus = BAD_INDEX;
1921 return *this;
1922 }
1923 s->what |= layer_state_t::eExtendedRangeBrightnessChanged;
Sally Qi963049b2023-03-23 14:06:21 -07001924 s->currentHdrSdrRatio = currentBufferRatio;
1925 s->desiredHdrSdrRatio = desiredRatio;
John Reck68796592023-01-25 13:47:12 -05001926
1927 registerSurfaceControlForCallback(sc);
1928 return *this;
1929}
1930
Alec Mouri1b0d4e12024-02-12 22:27:19 +00001931SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDesiredHdrHeadroom(
1932 const sp<SurfaceControl>& sc, float desiredRatio) {
1933 layer_state_t* s = getLayerState(sc);
1934 if (!s) {
1935 mStatus = BAD_INDEX;
1936 return *this;
1937 }
1938 s->what |= layer_state_t::eDesiredHdrHeadroomChanged;
1939 s->desiredHdrSdrRatio = desiredRatio;
1940
1941 registerSurfaceControlForCallback(sc);
1942 return *this;
1943}
1944
Sally Qi95f669a2024-08-27 11:31:42 -07001945SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLuts(
Sally Qi0abc4a52024-09-26 16:13:06 -07001946 const sp<SurfaceControl>& sc, const base::unique_fd& lutFd,
1947 const std::vector<int32_t>& offsets, const std::vector<int32_t>& dimensions,
1948 const std::vector<int32_t>& sizes, const std::vector<int32_t>& samplingKeys) {
Sally Qi95f669a2024-08-27 11:31:42 -07001949 layer_state_t* s = getLayerState(sc);
1950 if (!s) {
1951 mStatus = BAD_INDEX;
1952 return *this;
1953 }
Sally Qi0abc4a52024-09-26 16:13:06 -07001954
1955 s->luts = std::make_shared<gui::DisplayLuts>(base::unique_fd(dup(lutFd.get())), offsets,
1956 dimensions, sizes, samplingKeys);
1957 s->what |= layer_state_t::eLutsChanged;
1958
Sally Qi95f669a2024-08-27 11:31:42 -07001959 registerSurfaceControlForCallback(sc);
1960 return *this;
1961}
1962
Alec Mourif4af03e2023-02-11 00:25:24 +00001963SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCachingHint(
1964 const sp<SurfaceControl>& sc, gui::CachingHint cachingHint) {
1965 layer_state_t* s = getLayerState(sc);
1966 if (!s) {
1967 mStatus = BAD_INDEX;
1968 return *this;
1969 }
1970 s->what |= layer_state_t::eCachingHintChanged;
1971 s->cachingHint = cachingHint;
1972
1973 registerSurfaceControlForCallback(sc);
1974 return *this;
1975}
1976
Marissa Wall61c58622018-07-18 10:12:20 -07001977SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setHdrMetadata(
1978 const sp<SurfaceControl>& sc, const HdrMetadata& hdrMetadata) {
1979 layer_state_t* s = getLayerState(sc);
1980 if (!s) {
1981 mStatus = BAD_INDEX;
1982 return *this;
1983 }
1984 s->what |= layer_state_t::eHdrMetadataChanged;
1985 s->hdrMetadata = hdrMetadata;
Marissa Wallc837b5e2018-10-12 10:04:44 -07001986
1987 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07001988 return *this;
1989}
1990
1991SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSurfaceDamageRegion(
1992 const sp<SurfaceControl>& sc, const Region& surfaceDamageRegion) {
1993 layer_state_t* s = getLayerState(sc);
1994 if (!s) {
1995 mStatus = BAD_INDEX;
1996 return *this;
1997 }
1998 s->what |= layer_state_t::eSurfaceDamageRegionChanged;
1999 s->surfaceDamageRegion = surfaceDamageRegion;
Marissa Wallc837b5e2018-10-12 10:04:44 -07002000
2001 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07002002 return *this;
2003}
2004
2005SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setApi(
2006 const sp<SurfaceControl>& sc, int32_t api) {
2007 layer_state_t* s = getLayerState(sc);
2008 if (!s) {
2009 mStatus = BAD_INDEX;
2010 return *this;
2011 }
2012 s->what |= layer_state_t::eApiChanged;
2013 s->api = api;
Marissa Wallc837b5e2018-10-12 10:04:44 -07002014
2015 registerSurfaceControlForCallback(sc);
Marissa Wall61c58622018-07-18 10:12:20 -07002016 return *this;
2017}
2018
2019SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSidebandStream(
2020 const sp<SurfaceControl>& sc, const sp<NativeHandle>& sidebandStream) {
2021 layer_state_t* s = getLayerState(sc);
2022 if (!s) {
2023 mStatus = BAD_INDEX;
2024 return *this;
2025 }
2026 s->what |= layer_state_t::eSidebandStreamChanged;
2027 s->sidebandStream = sidebandStream;
Marissa Wallc837b5e2018-10-12 10:04:44 -07002028
2029 registerSurfaceControlForCallback(sc);
2030 return *this;
2031}
2032
Marissa Wall17b4e452018-12-26 16:32:34 -08002033SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDesiredPresentTime(
2034 nsecs_t desiredPresentTime) {
2035 mDesiredPresentTime = desiredPresentTime;
Ady Abrahamf0c56492020-12-17 18:04:15 -08002036 mIsAutoTimestamp = false;
Marissa Wall17b4e452018-12-26 16:32:34 -08002037 return *this;
2038}
2039
Peiyong Linc502cb72019-03-01 15:00:23 -08002040SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColorSpaceAgnostic(
2041 const sp<SurfaceControl>& sc, const bool agnostic) {
2042 layer_state_t* s = getLayerState(sc);
2043 if (!s) {
2044 mStatus = BAD_INDEX;
2045 return *this;
2046 }
2047 s->what |= layer_state_t::eColorSpaceAgnosticChanged;
2048 s->colorSpaceAgnostic = agnostic;
2049
2050 registerSurfaceControlForCallback(sc);
2051 return *this;
2052}
2053
Marissa Wallc837b5e2018-10-12 10:04:44 -07002054SurfaceComposerClient::Transaction&
Ana Krulecc84d09b2019-11-02 23:10:29 +01002055SurfaceComposerClient::Transaction::setFrameRateSelectionPriority(const sp<SurfaceControl>& sc,
2056 int32_t priority) {
2057 layer_state_t* s = getLayerState(sc);
2058 if (!s) {
2059 mStatus = BAD_INDEX;
2060 return *this;
2061 }
2062
2063 s->what |= layer_state_t::eFrameRateSelectionPriority;
2064 s->frameRateSelectionPriority = priority;
2065
2066 registerSurfaceControlForCallback(sc);
2067 return *this;
2068}
2069
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002070SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::addTransactionCallback(
2071 TransactionCompletedCallbackTakesContext callback, void* callbackContext,
2072 CallbackId::Type callbackType) {
Patrick Williams5312ec12024-08-23 16:11:10 -05002073 auto callbackWithContext =
2074 std::bind(std::move(callback), callbackContext, std::placeholders::_1,
2075 std::placeholders::_2, std::placeholders::_3);
Vishnu Naira74ba0f2024-04-16 11:25:06 -07002076 const auto& surfaceControls = mListenerCallbacks[mTransactionCompletedListener].surfaceControls;
Marissa Wallc837b5e2018-10-12 10:04:44 -07002077
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002078 CallbackId callbackId =
Vishnu Naira74ba0f2024-04-16 11:25:06 -07002079 mTransactionCompletedListener->addCallbackFunction(callbackWithContext, surfaceControls,
2080 callbackType);
Marissa Wallc837b5e2018-10-12 10:04:44 -07002081
Vishnu Naira74ba0f2024-04-16 11:25:06 -07002082 mListenerCallbacks[mTransactionCompletedListener].callbackIds.emplace(callbackId);
Marissa Wall61c58622018-07-18 10:12:20 -07002083 return *this;
2084}
2085
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002086SurfaceComposerClient::Transaction&
2087SurfaceComposerClient::Transaction::addTransactionCompletedCallback(
2088 TransactionCompletedCallbackTakesContext callback, void* callbackContext) {
Patrick Williams5312ec12024-08-23 16:11:10 -05002089 return addTransactionCallback(std::move(callback), callbackContext,
2090 CallbackId::Type::ON_COMPLETE);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002091}
2092
2093SurfaceComposerClient::Transaction&
2094SurfaceComposerClient::Transaction::addTransactionCommittedCallback(
2095 TransactionCompletedCallbackTakesContext callback, void* callbackContext) {
Patrick Williams5312ec12024-08-23 16:11:10 -05002096 return addTransactionCallback(std::move(callback), callbackContext,
2097 CallbackId::Type::ON_COMMIT);
Vishnu Nairfc46c1e2021-04-21 08:31:32 -07002098}
2099
Valerie Hau871d6352020-01-29 08:44:02 -08002100SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::notifyProducerDisconnect(
2101 const sp<SurfaceControl>& sc) {
2102 layer_state_t* s = getLayerState(sc);
2103 if (!s) {
2104 mStatus = BAD_INDEX;
2105 return *this;
2106 }
2107
2108 s->what |= layer_state_t::eProducerDisconnect;
2109 return *this;
2110}
2111
Robert Carr2c358bf2018-08-08 15:58:15 -07002112SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setInputWindowInfo(
chaviw98318de2021-05-19 16:45:23 -05002113 const sp<SurfaceControl>& sc, const WindowInfo& info) {
Robert Carr2c358bf2018-08-08 15:58:15 -07002114 layer_state_t* s = getLayerState(sc);
2115 if (!s) {
2116 mStatus = BAD_INDEX;
2117 return *this;
2118 }
chaviw98318de2021-05-19 16:45:23 -05002119 s->windowInfoHandle = new WindowInfoHandle(info);
Robert Carr2c358bf2018-08-08 15:58:15 -07002120 s->what |= layer_state_t::eInputInfoChanged;
2121 return *this;
2122}
chaviw273171b2018-12-26 11:46:30 -08002123
Vishnu Naire798b472020-07-23 13:52:21 -07002124SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFocusedWindow(
Vishnu Naire798b472020-07-23 13:52:21 -07002125 const FocusRequest& request) {
2126 mInputWindowCommands.focusRequests.push_back(request);
2127 return *this;
2128}
2129
Patrick Williamse5991f52022-06-23 20:23:43 +00002130SurfaceComposerClient::Transaction&
2131SurfaceComposerClient::Transaction::addWindowInfosReportedListener(
2132 sp<gui::IWindowInfosReportedListener> windowInfosReportedListener) {
2133 mInputWindowCommands.windowInfosReportedListeners.insert(windowInfosReportedListener);
chaviwa911b102019-02-14 10:18:33 -08002134 return *this;
2135}
2136
Peiyong Lind3788632018-09-18 16:01:31 -07002137SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColorTransform(
2138 const sp<SurfaceControl>& sc, const mat3& matrix, const vec3& translation) {
2139 layer_state_t* s = getLayerState(sc);
2140 if (!s) {
2141 mStatus = BAD_INDEX;
2142 return *this;
2143 }
2144 s->what |= layer_state_t::eColorTransformChanged;
2145 s->colorTransform = mat4(matrix, translation);
Marissa Wallc837b5e2018-10-12 10:04:44 -07002146
2147 registerSurfaceControlForCallback(sc);
Peiyong Lind3788632018-09-18 16:01:31 -07002148 return *this;
2149}
2150
Robert Carrfb4d58b2019-01-15 09:21:27 -08002151SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setGeometry(
2152 const sp<SurfaceControl>& sc, const Rect& source, const Rect& dst, int transform) {
chaviw25714502021-02-11 10:01:08 -08002153 setCrop(sc, source);
Robert Carrfb4d58b2019-01-15 09:21:27 -08002154
2155 int x = dst.left;
2156 int y = dst.top;
Robert Carr66365e42019-04-08 16:58:04 -07002157
2158 float sourceWidth = source.getWidth();
2159 float sourceHeight = source.getHeight();
2160
2161 float xScale = sourceWidth < 0 ? 1.0f : dst.getWidth() / sourceWidth;
2162 float yScale = sourceHeight < 0 ? 1.0f : dst.getHeight() / sourceHeight;
Robert Carrfb4d58b2019-01-15 09:21:27 -08002163 float matrix[4] = {1, 0, 0, 1};
2164
2165 switch (transform) {
2166 case NATIVE_WINDOW_TRANSFORM_FLIP_H:
2167 matrix[0] = -xScale; matrix[1] = 0;
2168 matrix[2] = 0; matrix[3] = yScale;
2169 x += source.getWidth();
2170 break;
2171 case NATIVE_WINDOW_TRANSFORM_FLIP_V:
2172 matrix[0] = xScale; matrix[1] = 0;
2173 matrix[2] = 0; matrix[3] = -yScale;
2174 y += source.getHeight();
2175 break;
2176 case NATIVE_WINDOW_TRANSFORM_ROT_90:
2177 matrix[0] = 0; matrix[1] = -yScale;
2178 matrix[2] = xScale; matrix[3] = 0;
2179 x += source.getHeight();
2180 break;
2181 case NATIVE_WINDOW_TRANSFORM_ROT_180:
2182 matrix[0] = -xScale; matrix[1] = 0;
2183 matrix[2] = 0; matrix[3] = -yScale;
2184 x += source.getWidth();
2185 y += source.getHeight();
2186 break;
2187 case NATIVE_WINDOW_TRANSFORM_ROT_270:
2188 matrix[0] = 0; matrix[1] = yScale;
2189 matrix[2] = -xScale; matrix[3] = 0;
2190 y += source.getWidth();
2191 break;
2192 default:
2193 matrix[0] = xScale; matrix[1] = 0;
2194 matrix[2] = 0; matrix[3] = yScale;
2195 break;
2196 }
2197 setMatrix(sc, matrix[0], matrix[1], matrix[2], matrix[3]);
chaviw76f5f2f2019-09-23 10:15:51 -07002198 float offsetX = xScale * source.left;
2199 float offsetY = yScale * source.top;
2200 setPosition(sc, x - offsetX, y - offsetY);
Robert Carrfb4d58b2019-01-15 09:21:27 -08002201
2202 return *this;
2203}
2204
Vishnu Nairc97b8db2019-10-29 18:19:35 -07002205SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setShadowRadius(
2206 const sp<SurfaceControl>& sc, float shadowRadius) {
2207 layer_state_t* s = getLayerState(sc);
2208 if (!s) {
2209 mStatus = BAD_INDEX;
2210 return *this;
2211 }
2212 s->what |= layer_state_t::eShadowRadiusChanged;
2213 s->shadowRadius = shadowRadius;
2214 return *this;
2215}
2216
Steven Thomas3172e202020-01-06 19:25:30 -08002217SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameRate(
Marin Shalamanov46084422020-10-13 12:33:42 +02002218 const sp<SurfaceControl>& sc, float frameRate, int8_t compatibility,
Marin Shalamanovc5986772021-03-16 16:09:49 +01002219 int8_t changeFrameRateStrategy) {
Steven Thomas3172e202020-01-06 19:25:30 -08002220 layer_state_t* s = getLayerState(sc);
2221 if (!s) {
2222 mStatus = BAD_INDEX;
2223 return *this;
2224 }
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002225 // Allow privileged values as well here, those will be ignored by SF if
2226 // the caller is not privileged
Marin Shalamanovc5986772021-03-16 16:09:49 +01002227 if (!ValidateFrameRate(frameRate, compatibility, changeFrameRateStrategy,
2228 "Transaction::setFrameRate",
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002229 /*privileged=*/true)) {
Steven Thomas62a4cf82020-01-31 12:04:03 -08002230 mStatus = BAD_VALUE;
2231 return *this;
2232 }
Steven Thomas3172e202020-01-06 19:25:30 -08002233 s->what |= layer_state_t::eFrameRateChanged;
2234 s->frameRate = frameRate;
Steven Thomas62a4cf82020-01-31 12:04:03 -08002235 s->frameRateCompatibility = compatibility;
Marin Shalamanovc5986772021-03-16 16:09:49 +01002236 s->changeFrameRateStrategy = changeFrameRateStrategy;
Steven Thomas3172e202020-01-06 19:25:30 -08002237 return *this;
2238}
2239
Andy Labrada096227e2022-06-15 16:58:11 +00002240SurfaceComposerClient::Transaction&
2241SurfaceComposerClient::Transaction::setDefaultFrameRateCompatibility(const sp<SurfaceControl>& sc,
2242 int8_t compatibility) {
2243 layer_state_t* s = getLayerState(sc);
2244 if (!s) {
2245 mStatus = BAD_INDEX;
2246 return *this;
2247 }
2248 s->what |= layer_state_t::eDefaultFrameRateCompatibilityChanged;
2249 s->defaultFrameRateCompatibility = compatibility;
2250 return *this;
2251}
2252
Rachel Leece6e0042023-06-27 11:22:54 -07002253SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameRateCategory(
Rachel Lee67afbea2023-09-28 15:35:07 -07002254 const sp<SurfaceControl>& sc, int8_t category, bool smoothSwitchOnly) {
Rachel Leece6e0042023-06-27 11:22:54 -07002255 layer_state_t* s = getLayerState(sc);
2256 if (!s) {
2257 mStatus = BAD_INDEX;
2258 return *this;
2259 }
2260 s->what |= layer_state_t::eFrameRateCategoryChanged;
2261 s->frameRateCategory = category;
Rachel Lee67afbea2023-09-28 15:35:07 -07002262 s->frameRateCategorySmoothSwitchOnly = smoothSwitchOnly;
Rachel Leece6e0042023-06-27 11:22:54 -07002263 return *this;
2264}
2265
Rachel Lee58cc90d2023-09-05 18:50:20 -07002266SurfaceComposerClient::Transaction&
2267SurfaceComposerClient::Transaction::setFrameRateSelectionStrategy(const sp<SurfaceControl>& sc,
2268 int8_t strategy) {
2269 layer_state_t* s = getLayerState(sc);
2270 if (!s) {
2271 mStatus = BAD_INDEX;
2272 return *this;
2273 }
2274 s->what |= layer_state_t::eFrameRateSelectionStrategyChanged;
2275 s->frameRateSelectionStrategy = strategy;
2276 return *this;
2277}
2278
Vishnu Nair6213bd92020-05-08 17:42:25 -07002279SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFixedTransformHint(
2280 const sp<SurfaceControl>& sc, int32_t fixedTransformHint) {
2281 layer_state_t* s = getLayerState(sc);
2282 if (!s) {
2283 mStatus = BAD_INDEX;
2284 return *this;
2285 }
2286
2287 const ui::Transform::RotationFlags transform = fixedTransformHint == -1
2288 ? ui::Transform::ROT_INVALID
2289 : ui::Transform::toRotationFlags(static_cast<ui::Rotation>(fixedTransformHint));
2290 s->what |= layer_state_t::eFixedTransformHintChanged;
2291 s->fixedTransformHint = transform;
2292 return *this;
2293}
2294
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10002295SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameTimelineInfo(
2296 const FrameTimelineInfo& frameTimelineInfo) {
Huihong Luo3bdef862022-03-03 11:57:19 -08002297 mergeFrameTimelineInfo(mFrameTimelineInfo, frameTimelineInfo);
Robert Carr9b611b72020-10-19 12:00:23 -07002298 return *this;
2299}
2300
Vishnu Naircf26a0a2020-11-13 12:56:20 -08002301SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setAutoRefresh(
2302 const sp<SurfaceControl>& sc, bool autoRefresh) {
2303 layer_state_t* s = getLayerState(sc);
2304 if (!s) {
2305 mStatus = BAD_INDEX;
2306 return *this;
2307 }
2308
2309 s->what |= layer_state_t::eAutoRefreshChanged;
2310 s->autoRefresh = autoRefresh;
2311 return *this;
2312}
2313
Winson Chunga30f7c92021-06-29 15:42:56 -07002314SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTrustedOverlay(
2315 const sp<SurfaceControl>& sc, bool isTrustedOverlay) {
Vishnu Nair9e0017e2024-05-22 19:02:44 +00002316 return setTrustedOverlay(sc,
2317 isTrustedOverlay ? gui::TrustedOverlay::ENABLED
2318 : gui::TrustedOverlay::UNSET);
2319}
2320
2321SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTrustedOverlay(
2322 const sp<SurfaceControl>& sc, gui::TrustedOverlay trustedOverlay) {
Winson Chunga30f7c92021-06-29 15:42:56 -07002323 layer_state_t* s = getLayerState(sc);
2324 if (!s) {
2325 mStatus = BAD_INDEX;
2326 return *this;
2327 }
2328
2329 s->what |= layer_state_t::eTrustedOverlayChanged;
Vishnu Nair9e0017e2024-05-22 19:02:44 +00002330 s->trustedOverlay = trustedOverlay;
Winson Chunga30f7c92021-06-29 15:42:56 -07002331 return *this;
2332}
2333
Vishnu Nair277142c2021-01-05 18:35:29 -08002334SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setApplyToken(
2335 const sp<IBinder>& applyToken) {
2336 mApplyToken = applyToken;
2337 return *this;
2338}
2339
John Reckcdb4ed72021-02-04 13:39:33 -05002340SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setStretchEffect(
Nader Jawad2dfc98b2021-04-08 20:35:39 -07002341 const sp<SurfaceControl>& sc, const StretchEffect& stretchEffect) {
John Reckcdb4ed72021-02-04 13:39:33 -05002342 layer_state_t* s = getLayerState(sc);
2343 if (!s) {
2344 mStatus = BAD_INDEX;
2345 return *this;
2346 }
2347
2348 s->what |= layer_state_t::eStretchChanged;
Nader Jawad2dfc98b2021-04-08 20:35:39 -07002349 s->stretchEffect = stretchEffect;
John Reckcdb4ed72021-02-04 13:39:33 -05002350 return *this;
2351}
2352
Marzia Favaroc9918bf2024-07-10 14:45:35 +00002353bool SurfaceComposerClient::flagEdgeExtensionEffectUseShader() {
2354 return com::android::graphics::libgui::flags::edge_extension_shader();
2355}
2356
Marzia Favarodcc9d9b2024-01-10 10:17:00 +00002357SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setEdgeExtensionEffect(
2358 const sp<SurfaceControl>& sc, const gui::EdgeExtensionParameters& effect) {
2359 layer_state_t* s = getLayerState(sc);
2360 if (!s) {
2361 mStatus = BAD_INDEX;
2362 return *this;
2363 }
2364
2365 s->what |= layer_state_t::eEdgeExtensionChanged;
2366 s->edgeExtensionParameters = effect;
2367 return *this;
2368}
2369
chaviwf3f40fe2021-04-27 15:54:02 -05002370SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBufferCrop(
2371 const sp<SurfaceControl>& sc, const Rect& bufferCrop) {
2372 layer_state_t* s = getLayerState(sc);
2373 if (!s) {
2374 mStatus = BAD_INDEX;
2375 return *this;
2376 }
2377
2378 s->what |= layer_state_t::eBufferCropChanged;
2379 s->bufferCrop = bufferCrop;
2380
2381 registerSurfaceControlForCallback(sc);
2382 return *this;
2383}
2384
Vishnu Nair6bdec7d2021-05-10 15:01:13 -07002385SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDestinationFrame(
2386 const sp<SurfaceControl>& sc, const Rect& destinationFrame) {
2387 layer_state_t* s = getLayerState(sc);
2388 if (!s) {
2389 mStatus = BAD_INDEX;
2390 return *this;
2391 }
2392
2393 s->what |= layer_state_t::eDestinationFrameChanged;
2394 s->destinationFrame = destinationFrame;
2395
2396 registerSurfaceControlForCallback(sc);
2397 return *this;
2398}
2399
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -07002400SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDropInputMode(
2401 const sp<SurfaceControl>& sc, gui::DropInputMode mode) {
2402 layer_state_t* s = getLayerState(sc);
2403 if (!s) {
2404 mStatus = BAD_INDEX;
2405 return *this;
2406 }
2407
2408 s->what |= layer_state_t::eDropInputModeChanged;
2409 s->dropInputMode = mode;
2410
2411 registerSurfaceControlForCallback(sc);
2412 return *this;
2413}
2414
Patrick Williamsf693bcf2024-08-02 09:55:23 -05002415SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setBufferReleaseChannel(
2416 const sp<SurfaceControl>& sc,
2417 const std::shared_ptr<gui::BufferReleaseChannel::ProducerEndpoint>& channel) {
2418 layer_state_t* s = getLayerState(sc);
2419 if (!s) {
2420 mStatus = BAD_INDEX;
2421 return *this;
2422 }
2423
2424 s->what |= layer_state_t::eBufferReleaseChannelChanged;
2425 s->bufferReleaseChannel = channel;
2426
2427 registerSurfaceControlForCallback(sc);
2428 return *this;
2429}
2430
Mathias Agopian698c0872011-06-28 19:09:31 -07002431// ---------------------------------------------------------------------------
2432
chaviw763ef572018-02-22 16:04:57 -08002433DisplayState& SurfaceComposerClient::Transaction::getDisplayState(const sp<IBinder>& token) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07002434 DisplayState s;
2435 s.token = token;
2436 ssize_t index = mDisplayStates.indexOf(s);
2437 if (index < 0) {
2438 // we don't have it, add an initialized layer_state to our list
2439 s.what = 0;
2440 index = mDisplayStates.add(s);
2441 }
Dan Stozad723bd72014-11-18 10:24:03 -08002442 return mDisplayStates.editItemAt(static_cast<size_t>(index));
Mathias Agopiane57f2922012-08-09 16:29:12 -07002443}
2444
Robert Carr4cdc58f2017-08-23 14:22:20 -07002445status_t SurfaceComposerClient::Transaction::setDisplaySurface(const sp<IBinder>& token,
2446 const sp<IGraphicBufferProducer>& bufferProducer) {
Pablo Ceballoseddbef82016-09-01 11:21:21 -07002447 if (bufferProducer.get() != nullptr) {
2448 // Make sure that composition can never be stalled by a virtual display
2449 // consumer that isn't processing buffers fast enough.
2450 status_t err = bufferProducer->setAsyncMode(true);
2451 if (err != NO_ERROR) {
2452 ALOGE("Composer::setDisplaySurface Failed to enable async mode on the "
2453 "BufferQueue. This BufferQueue cannot be used for virtual "
2454 "display. (%d)", err);
2455 return err;
2456 }
Pablo Ceballos1aad24c2016-08-04 10:24:22 -07002457 }
chaviw763ef572018-02-22 16:04:57 -08002458 DisplayState& s(getDisplayState(token));
Andy McFadden2adaf042012-12-18 09:49:45 -08002459 s.surface = bufferProducer;
Mathias Agopiane57f2922012-08-09 16:29:12 -07002460 s.what |= DisplayState::eSurfaceChanged;
Pablo Ceballos1aad24c2016-08-04 10:24:22 -07002461 return NO_ERROR;
Mathias Agopiane57f2922012-08-09 16:29:12 -07002462}
2463
Robert Carr4cdc58f2017-08-23 14:22:20 -07002464void SurfaceComposerClient::Transaction::setDisplayLayerStack(const sp<IBinder>& token,
Dominik Laskowski29fa1462021-04-27 15:51:50 -07002465 ui::LayerStack layerStack) {
chaviw763ef572018-02-22 16:04:57 -08002466 DisplayState& s(getDisplayState(token));
Mathias Agopiane57f2922012-08-09 16:29:12 -07002467 s.layerStack = layerStack;
2468 s.what |= DisplayState::eLayerStackChanged;
2469}
2470
Evan Rosky2239b372021-05-20 13:43:47 -07002471void SurfaceComposerClient::Transaction::setDisplayFlags(const sp<IBinder>& token, uint32_t flags) {
2472 DisplayState& s(getDisplayState(token));
2473 s.flags = flags;
2474 s.what |= DisplayState::eFlagsChanged;
2475}
2476
Robert Carr4cdc58f2017-08-23 14:22:20 -07002477void SurfaceComposerClient::Transaction::setDisplayProjection(const sp<IBinder>& token,
Dominik Laskowski718f9602019-11-09 20:01:35 -08002478 ui::Rotation orientation,
2479 const Rect& layerStackRect,
2480 const Rect& displayRect) {
chaviw763ef572018-02-22 16:04:57 -08002481 DisplayState& s(getDisplayState(token));
Mathias Agopiane57f2922012-08-09 16:29:12 -07002482 s.orientation = orientation;
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002483 s.layerStackSpaceRect = layerStackRect;
2484 s.orientedDisplaySpaceRect = displayRect;
Mathias Agopian00e8c7a2012-09-04 19:30:46 -07002485 s.what |= DisplayState::eDisplayProjectionChanged;
Mathias Agopiane57f2922012-08-09 16:29:12 -07002486}
2487
Robert Carr4cdc58f2017-08-23 14:22:20 -07002488void SurfaceComposerClient::Transaction::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height) {
chaviw763ef572018-02-22 16:04:57 -08002489 DisplayState& s(getDisplayState(token));
Michael Wright1f6078a2014-06-26 16:01:02 -07002490 s.width = width;
2491 s.height = height;
2492 s.what |= DisplayState::eDisplaySizeChanged;
2493}
2494
Huihong Luo3bdef862022-03-03 11:57:19 -08002495// copied from FrameTimelineInfo::merge()
2496void SurfaceComposerClient::Transaction::mergeFrameTimelineInfo(FrameTimelineInfo& t,
2497 const FrameTimelineInfo& other) {
2498 // When merging vsync Ids we take the oldest valid one
2499 if (t.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID &&
2500 other.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
2501 if (other.vsyncId > t.vsyncId) {
Ady Abraham88930f92023-06-07 10:32:08 -07002502 t = other;
Huihong Luo3bdef862022-03-03 11:57:19 -08002503 }
2504 } else if (t.vsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {
Ady Abraham88930f92023-06-07 10:32:08 -07002505 t = other;
Huihong Luo3bdef862022-03-03 11:57:19 -08002506 }
2507}
2508
Chavi Weingarten076acac2023-01-19 17:20:43 +00002509SurfaceComposerClient::Transaction&
2510SurfaceComposerClient::Transaction::setTrustedPresentationCallback(
2511 const sp<SurfaceControl>& sc, TrustedPresentationCallback cb,
2512 const TrustedPresentationThresholds& thresholds, void* context,
2513 sp<SurfaceComposerClient::PresentationCallbackRAII>& outCallbackRef) {
Vishnu Naira74ba0f2024-04-16 11:25:06 -07002514 outCallbackRef =
2515 mTransactionCompletedListener->addTrustedPresentationCallback(cb, sc->getLayerId(),
2516 context);
Chavi Weingarten076acac2023-01-19 17:20:43 +00002517
2518 layer_state_t* s = getLayerState(sc);
2519 if (!s) {
2520 mStatus = BAD_INDEX;
2521 return *this;
2522 }
2523 s->what |= layer_state_t::eTrustedPresentationInfoChanged;
2524 s->trustedPresentationThresholds = thresholds;
2525 s->trustedPresentationListener.callbackInterface = TransactionCompletedListener::getIInstance();
2526 s->trustedPresentationListener.callbackId = sc->getLayerId();
2527
2528 return *this;
2529}
2530
2531SurfaceComposerClient::Transaction&
2532SurfaceComposerClient::Transaction::clearTrustedPresentationCallback(const sp<SurfaceControl>& sc) {
Vishnu Naira74ba0f2024-04-16 11:25:06 -07002533 mTransactionCompletedListener->clearTrustedPresentationCallback(sc->getLayerId());
Chavi Weingarten076acac2023-01-19 17:20:43 +00002534
2535 layer_state_t* s = getLayerState(sc);
2536 if (!s) {
2537 mStatus = BAD_INDEX;
2538 return *this;
2539 }
2540 s->what |= layer_state_t::eTrustedPresentationInfoChanged;
2541 s->trustedPresentationThresholds = TrustedPresentationThresholds();
2542 s->trustedPresentationListener.callbackInterface = nullptr;
2543 s->trustedPresentationListener.callbackId = -1;
2544
2545 return *this;
2546}
2547
Mathias Agopiane57f2922012-08-09 16:29:12 -07002548// ---------------------------------------------------------------------------
2549
chaviw60c9d3e2021-06-04 12:52:17 -05002550SurfaceComposerClient::SurfaceComposerClient() : mStatus(NO_INIT) {}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002551
Jorim Jaggif3cf4bc2017-11-30 14:19:23 +01002552SurfaceComposerClient::SurfaceComposerClient(const sp<ISurfaceComposerClient>& client)
chaviw60c9d3e2021-06-04 12:52:17 -05002553 : mStatus(NO_ERROR), mClient(client) {}
Jorim Jaggif3cf4bc2017-11-30 14:19:23 +01002554
Mathias Agopian698c0872011-06-28 19:09:31 -07002555void SurfaceComposerClient::onFirstRef() {
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002556 sp<gui::ISurfaceComposer> sf(ComposerServiceAIDL::getComposerService());
Yi Kong48a619f2018-06-05 16:34:59 -07002557 if (sf != nullptr && mStatus == NO_INIT) {
Robert Carr1db73f62016-12-21 12:58:51 -08002558 sp<ISurfaceComposerClient> conn;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002559 binder::Status status = sf->createConnection(&conn);
2560 if (status.isOk() && conn != nullptr) {
Mathias Agopiand4784a32010-05-27 19:41:15 -07002561 mClient = conn;
Mathias Agopiand4784a32010-05-27 19:41:15 -07002562 mStatus = NO_ERROR;
2563 }
2564 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002565}
2566
Mathias Agopian698c0872011-06-28 19:09:31 -07002567SurfaceComposerClient::~SurfaceComposerClient() {
Mathias Agopian631f3582010-05-25 17:51:34 -07002568 dispose();
2569}
Mathias Agopiandd3423c2009-09-23 15:44:05 -07002570
Mathias Agopian698c0872011-06-28 19:09:31 -07002571status_t SurfaceComposerClient::initCheck() const {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002572 return mStatus;
2573}
2574
Mathias Agopian698c0872011-06-28 19:09:31 -07002575sp<IBinder> SurfaceComposerClient::connection() const {
Marco Nelissen2ea926b2014-11-14 08:01:01 -08002576 return IInterface::asBinder(mClient);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002577}
2578
Mathias Agopiand4784a32010-05-27 19:41:15 -07002579status_t SurfaceComposerClient::linkToComposerDeath(
2580 const sp<IBinder::DeathRecipient>& recipient,
Mathias Agopian698c0872011-06-28 19:09:31 -07002581 void* cookie, uint32_t flags) {
Robert Carr4cdc58f2017-08-23 14:22:20 -07002582 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
2583 return IInterface::asBinder(sf)->linkToDeath(recipient, cookie, flags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002584}
2585
Mathias Agopian698c0872011-06-28 19:09:31 -07002586void SurfaceComposerClient::dispose() {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002587 // this can be called more than once.
Mathias Agopian7e27f052010-05-28 14:22:23 -07002588 sp<ISurfaceComposerClient> client;
Mathias Agopiand4784a32010-05-27 19:41:15 -07002589 Mutex::Autolock _lm(mLock);
Yi Kong48a619f2018-06-05 16:34:59 -07002590 if (mClient != nullptr) {
Mathias Agopiand4784a32010-05-27 19:41:15 -07002591 client = mClient; // hold ref while lock is held
2592 mClient.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002593 }
Mathias Agopiand4784a32010-05-27 19:41:15 -07002594 mStatus = NO_INIT;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002595}
2596
Carlos Martinez Romero4609a4a2022-11-30 00:38:11 +00002597status_t SurfaceComposerClient::bootFinished() {
2598 sp<gui::ISurfaceComposer> sf(ComposerServiceAIDL::getComposerService());
2599 binder::Status status = sf->bootFinished();
2600 return statusTFromBinderStatus(status);
2601}
2602
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002603sp<SurfaceControl> SurfaceComposerClient::createSurface(const String8& name, uint32_t w, uint32_t h,
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002604 PixelFormat format, int32_t flags,
Vishnu Nair992496b2020-10-22 17:27:21 -07002605 const sp<IBinder>& parentHandle,
Valerie Hau1acd6962019-10-28 16:35:48 -07002606 LayerMetadata metadata,
2607 uint32_t* outTransformHint) {
Robert Carr3b382ed2018-03-14 13:49:41 -07002608 sp<SurfaceControl> s;
Vishnu Nair992496b2020-10-22 17:27:21 -07002609 createSurfaceChecked(name, w, h, format, &s, flags, parentHandle, std::move(metadata),
Valerie Hau1acd6962019-10-28 16:35:48 -07002610 outTransformHint);
Robert Carr3b382ed2018-03-14 13:49:41 -07002611 return s;
2612}
2613
Patrick Williamsa361de62022-10-06 20:34:10 +00002614static std::string toString(const String16& string) {
2615 return std::string(String8(string).c_str());
2616}
2617
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002618status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
2619 PixelFormat format,
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002620 sp<SurfaceControl>* outSurface, int32_t flags,
Vishnu Nair992496b2020-10-22 17:27:21 -07002621 const sp<IBinder>& parentHandle,
2622 LayerMetadata metadata,
Valerie Hau1acd6962019-10-28 16:35:48 -07002623 uint32_t* outTransformHint) {
Robert Carr740eaf02018-03-27 12:59:18 -07002624 status_t err = mStatus;
Robert Carr3b382ed2018-03-14 13:49:41 -07002625
Mathias Agopian698c0872011-06-28 19:09:31 -07002626 if (mStatus == NO_ERROR) {
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002627 gui::CreateSurfaceResult result;
Tomasz Wasilczyk02fd95c2023-08-30 17:51:31 +00002628 binder::Status status = mClient->createSurface(std::string(name.c_str()), flags,
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002629 parentHandle, std::move(metadata), &result);
2630 err = statusTFromBinderStatus(status);
Valerie Hau1acd6962019-10-28 16:35:48 -07002631 if (outTransformHint) {
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002632 *outTransformHint = result.transformHint;
Valerie Hau1acd6962019-10-28 16:35:48 -07002633 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07002634 ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
2635 if (err == NO_ERROR) {
Patrick Williamsa361de62022-10-06 20:34:10 +00002636 *outSurface = new SurfaceControl(this, result.handle, result.layerId,
2637 toString(result.layerName), w, h, format,
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002638 result.transformHint, flags);
Mathias Agopian698c0872011-06-28 19:09:31 -07002639 }
2640 }
Robert Carr3b382ed2018-03-14 13:49:41 -07002641 return err;
Mathias Agopian698c0872011-06-28 19:09:31 -07002642}
2643
chaviwfe94a222019-08-21 13:52:59 -07002644sp<SurfaceControl> SurfaceComposerClient::mirrorSurface(SurfaceControl* mirrorFromSurface) {
2645 if (mirrorFromSurface == nullptr) {
2646 return nullptr;
2647 }
2648
chaviwfe94a222019-08-21 13:52:59 -07002649 sp<IBinder> mirrorFromHandle = mirrorFromSurface->getHandle();
Patrick Williamsa361de62022-10-06 20:34:10 +00002650 gui::CreateSurfaceResult result;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002651 const binder::Status status = mClient->mirrorSurface(mirrorFromHandle, &result);
2652 const status_t err = statusTFromBinderStatus(status);
chaviwfe94a222019-08-21 13:52:59 -07002653 if (err == NO_ERROR) {
Patrick Williamsa361de62022-10-06 20:34:10 +00002654 return new SurfaceControl(this, result.handle, result.layerId, toString(result.layerName));
chaviwfe94a222019-08-21 13:52:59 -07002655 }
2656 return nullptr;
2657}
2658
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00002659sp<SurfaceControl> SurfaceComposerClient::mirrorDisplay(DisplayId displayId) {
Patrick Williamsa361de62022-10-06 20:34:10 +00002660 gui::CreateSurfaceResult result;
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00002661 const binder::Status status = mClient->mirrorDisplay(displayId.value, &result);
2662 const status_t err = statusTFromBinderStatus(status);
2663 if (err == NO_ERROR) {
Patrick Williamsa361de62022-10-06 20:34:10 +00002664 return new SurfaceControl(this, result.handle, result.layerId, toString(result.layerName));
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00002665 }
2666 return nullptr;
2667}
2668
Svetoslavd85084b2014-03-20 10:28:31 -07002669status_t SurfaceComposerClient::clearLayerFrameStats(const sp<IBinder>& token) const {
2670 if (mStatus != NO_ERROR) {
2671 return mStatus;
2672 }
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002673 const binder::Status status = mClient->clearLayerFrameStats(token);
2674 return statusTFromBinderStatus(status);
Svetoslavd85084b2014-03-20 10:28:31 -07002675}
2676
2677status_t SurfaceComposerClient::getLayerFrameStats(const sp<IBinder>& token,
2678 FrameStats* outStats) const {
2679 if (mStatus != NO_ERROR) {
2680 return mStatus;
2681 }
Huihong Luod3d8f8e2022-03-08 14:48:46 -08002682 gui::FrameStats stats;
2683 const binder::Status status = mClient->getLayerFrameStats(token, &stats);
2684 if (status.isOk()) {
2685 outStats->refreshPeriodNano = stats.refreshPeriodNano;
2686 outStats->desiredPresentTimesNano.setCapacity(stats.desiredPresentTimesNano.size());
2687 for (const auto& t : stats.desiredPresentTimesNano) {
2688 outStats->desiredPresentTimesNano.add(t);
2689 }
2690 outStats->actualPresentTimesNano.setCapacity(stats.actualPresentTimesNano.size());
2691 for (const auto& t : stats.actualPresentTimesNano) {
2692 outStats->actualPresentTimesNano.add(t);
2693 }
2694 outStats->frameReadyTimesNano.setCapacity(stats.frameReadyTimesNano.size());
2695 for (const auto& t : stats.frameReadyTimesNano) {
2696 outStats->frameReadyTimesNano.add(t);
2697 }
2698 }
2699 return statusTFromBinderStatus(status);
Svetoslavd85084b2014-03-20 10:28:31 -07002700}
2701
Mathias Agopian698c0872011-06-28 19:09:31 -07002702// ----------------------------------------------------------------------------
2703
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08002704status_t SurfaceComposerClient::getDisplayState(const sp<IBinder>& display,
2705 ui::DisplayState* state) {
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08002706 gui::DisplayState ds;
2707 binder::Status status =
2708 ComposerServiceAIDL::getComposerService()->getDisplayState(display, &ds);
2709 if (status.isOk()) {
2710 state->layerStack = ui::LayerStack::fromValue(ds.layerStack);
2711 state->orientation = static_cast<ui::Rotation>(ds.orientation);
2712 state->layerStackSpaceRect =
2713 ui::Size(ds.layerStackSpaceRect.width, ds.layerStackSpaceRect.height);
2714 }
Huihong Luo3bdef862022-03-03 11:57:19 -08002715 return statusTFromBinderStatus(status);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08002716}
2717
Sally Qi6bb12822022-10-05 11:42:30 -07002718status_t SurfaceComposerClient::getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08002719 ui::StaticDisplayInfo* outInfo) {
2720 using Tag = android::gui::DeviceProductInfo::ManufactureOrModelDate::Tag;
2721 gui::StaticDisplayInfo ginfo;
2722 binder::Status status =
Sally Qi6bb12822022-10-05 11:42:30 -07002723 ComposerServiceAIDL::getComposerService()->getStaticDisplayInfo(displayId, &ginfo);
Huihong Luoa79ddf42022-02-17 00:01:38 -08002724 if (status.isOk()) {
2725 // convert gui::StaticDisplayInfo to ui::StaticDisplayInfo
2726 outInfo->connectionType = static_cast<ui::DisplayConnectionType>(ginfo.connectionType);
2727 outInfo->density = ginfo.density;
2728 outInfo->secure = ginfo.secure;
2729 outInfo->installOrientation = static_cast<ui::Rotation>(ginfo.installOrientation);
2730
Snild Dolkow8d675642023-07-14 12:43:35 +02002731 if (const std::optional<gui::DeviceProductInfo> dpi = ginfo.deviceProductInfo) {
2732 DeviceProductInfo info;
2733 info.name = dpi->name;
2734 if (dpi->manufacturerPnpId.size() > 0) {
2735 // copid from PnpId = std::array<char, 4> in ui/DeviceProductInfo.h
2736 constexpr int kMaxPnpIdSize = 4;
2737 size_t count = std::max<size_t>(kMaxPnpIdSize, dpi->manufacturerPnpId.size());
2738 std::copy_n(dpi->manufacturerPnpId.begin(), count, info.manufacturerPnpId.begin());
2739 }
2740 if (dpi->relativeAddress.size() > 0) {
2741 std::copy(dpi->relativeAddress.begin(), dpi->relativeAddress.end(),
2742 std::back_inserter(info.relativeAddress));
2743 }
2744 info.productId = dpi->productId;
Huihong Luoa79ddf42022-02-17 00:01:38 -08002745
Snild Dolkow8d675642023-07-14 12:43:35 +02002746 const gui::DeviceProductInfo::ManufactureOrModelDate& date =
2747 dpi->manufactureOrModelDate;
2748 if (date.getTag() == Tag::modelYear) {
2749 DeviceProductInfo::ModelYear modelYear;
2750 modelYear.year = static_cast<uint32_t>(date.get<Tag::modelYear>().year);
2751 info.manufactureOrModelDate = modelYear;
2752 } else if (date.getTag() == Tag::manufactureYear) {
2753 DeviceProductInfo::ManufactureYear manufactureYear;
2754 manufactureYear.year = date.get<Tag::manufactureYear>().modelYear.year;
2755 info.manufactureOrModelDate = manufactureYear;
2756 } else if (date.getTag() == Tag::manufactureWeekAndYear) {
2757 DeviceProductInfo::ManufactureWeekAndYear weekAndYear;
2758 weekAndYear.year =
2759 date.get<Tag::manufactureWeekAndYear>().manufactureYear.modelYear.year;
2760 weekAndYear.week = date.get<Tag::manufactureWeekAndYear>().week;
2761 info.manufactureOrModelDate = weekAndYear;
2762 }
2763
2764 outInfo->deviceProductInfo = info;
2765 }
Huihong Luoa79ddf42022-02-17 00:01:38 -08002766 }
Huihong Luo3bdef862022-03-03 11:57:19 -08002767 return statusTFromBinderStatus(status);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08002768}
2769
Sally Qi6bb12822022-10-05 11:42:30 -07002770void SurfaceComposerClient::getDynamicDisplayInfoInternal(gui::DynamicDisplayInfo& ginfo,
2771 ui::DynamicDisplayInfo*& outInfo) {
2772 // convert gui::DynamicDisplayInfo to ui::DynamicDisplayInfo
2773 outInfo->supportedDisplayModes.clear();
2774 outInfo->supportedDisplayModes.reserve(ginfo.supportedDisplayModes.size());
2775 for (const auto& mode : ginfo.supportedDisplayModes) {
2776 ui::DisplayMode outMode;
2777 outMode.id = mode.id;
2778 outMode.resolution.width = mode.resolution.width;
2779 outMode.resolution.height = mode.resolution.height;
2780 outMode.xDpi = mode.xDpi;
2781 outMode.yDpi = mode.yDpi;
Alec Mouri55e31032023-10-02 20:34:18 +00002782 outMode.peakRefreshRate = mode.peakRefreshRate;
Alec Mourid122a1c2023-09-30 01:36:33 +00002783 outMode.vsyncRate = mode.vsyncRate;
Sally Qi6bb12822022-10-05 11:42:30 -07002784 outMode.appVsyncOffset = mode.appVsyncOffset;
2785 outMode.sfVsyncOffset = mode.sfVsyncOffset;
2786 outMode.presentationDeadline = mode.presentationDeadline;
2787 outMode.group = mode.group;
2788 std::transform(mode.supportedHdrTypes.begin(), mode.supportedHdrTypes.end(),
2789 std::back_inserter(outMode.supportedHdrTypes),
2790 [](const int32_t& value) { return static_cast<ui::Hdr>(value); });
2791 outInfo->supportedDisplayModes.push_back(outMode);
2792 }
2793
2794 outInfo->activeDisplayModeId = ginfo.activeDisplayModeId;
2795 outInfo->renderFrameRate = ginfo.renderFrameRate;
2796
2797 outInfo->supportedColorModes.clear();
2798 outInfo->supportedColorModes.reserve(ginfo.supportedColorModes.size());
2799 for (const auto& cmode : ginfo.supportedColorModes) {
2800 outInfo->supportedColorModes.push_back(static_cast<ui::ColorMode>(cmode));
2801 }
2802
2803 outInfo->activeColorMode = static_cast<ui::ColorMode>(ginfo.activeColorMode);
2804
2805 std::vector<ui::Hdr> types;
2806 types.reserve(ginfo.hdrCapabilities.supportedHdrTypes.size());
2807 for (const auto& hdr : ginfo.hdrCapabilities.supportedHdrTypes) {
2808 types.push_back(static_cast<ui::Hdr>(hdr));
2809 }
2810 outInfo->hdrCapabilities = HdrCapabilities(types, ginfo.hdrCapabilities.maxLuminance,
2811 ginfo.hdrCapabilities.maxAverageLuminance,
2812 ginfo.hdrCapabilities.minLuminance);
2813
2814 outInfo->autoLowLatencyModeSupported = ginfo.autoLowLatencyModeSupported;
2815 outInfo->gameContentTypeSupported = ginfo.gameContentTypeSupported;
2816 outInfo->preferredBootDisplayMode = ginfo.preferredBootDisplayMode;
ramindani89fbb6e2024-09-26 11:30:24 -07002817 outInfo->hasArrSupport = ginfo.hasArrSupport;
ramindani8204da22024-10-18 15:22:52 -07002818 outInfo->frameRateCategoryRate = ui::FrameRateCategoryRate(ginfo.frameRateCategoryRate.normal,
2819 ginfo.frameRateCategoryRate.high);
Sally Qi6bb12822022-10-05 11:42:30 -07002820}
2821
2822status_t SurfaceComposerClient::getDynamicDisplayInfoFromId(int64_t displayId,
2823 ui::DynamicDisplayInfo* outInfo) {
Huihong Luo38603fd2022-02-21 14:32:54 -08002824 gui::DynamicDisplayInfo ginfo;
2825 binder::Status status =
Sally Qi6bb12822022-10-05 11:42:30 -07002826 ComposerServiceAIDL::getComposerService()->getDynamicDisplayInfoFromId(displayId,
2827 &ginfo);
Huihong Luo38603fd2022-02-21 14:32:54 -08002828 if (status.isOk()) {
Sally Qi6bb12822022-10-05 11:42:30 -07002829 getDynamicDisplayInfoInternal(ginfo, outInfo);
2830 }
2831 return statusTFromBinderStatus(status);
2832}
Huihong Luo38603fd2022-02-21 14:32:54 -08002833
Sally Qi6bb12822022-10-05 11:42:30 -07002834status_t SurfaceComposerClient::getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
2835 ui::DynamicDisplayInfo* outInfo) {
2836 gui::DynamicDisplayInfo ginfo;
2837 binder::Status status =
2838 ComposerServiceAIDL::getComposerService()->getDynamicDisplayInfoFromToken(display,
2839 &ginfo);
2840 if (status.isOk()) {
2841 getDynamicDisplayInfoInternal(ginfo, outInfo);
Huihong Luo38603fd2022-02-21 14:32:54 -08002842 }
Huihong Luo3bdef862022-03-03 11:57:19 -08002843 return statusTFromBinderStatus(status);
Dan Stoza7f7da322014-05-02 15:26:25 -07002844}
2845
Marin Shalamanova7fe3042021-01-29 21:02:08 +01002846status_t SurfaceComposerClient::getActiveDisplayMode(const sp<IBinder>& display,
2847 ui::DisplayMode* mode) {
Marin Shalamanov228f46b2021-01-28 21:11:45 +01002848 ui::DynamicDisplayInfo info;
Sally Qi6bb12822022-10-05 11:42:30 -07002849
2850 status_t result = getDynamicDisplayInfoFromToken(display, &info);
Dan Stoza7f7da322014-05-02 15:26:25 -07002851 if (result != NO_ERROR) {
2852 return result;
2853 }
2854
Marin Shalamanov228f46b2021-01-28 21:11:45 +01002855 if (const auto activeMode = info.getActiveDisplayMode()) {
2856 *mode = *activeMode;
2857 return NO_ERROR;
Dan Stoza7f7da322014-05-02 15:26:25 -07002858 }
2859
Marin Shalamanov228f46b2021-01-28 21:11:45 +01002860 ALOGE("Active display mode not found.");
2861 return NAME_NOT_FOUND;
Dan Stoza7f7da322014-05-02 15:26:25 -07002862}
2863
Ady Abraham285f8c12022-10-11 17:12:14 -07002864status_t SurfaceComposerClient::setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
2865 const gui::DisplayModeSpecs& specs) {
Huihong Luo02186fb2022-02-23 14:21:54 -08002866 binder::Status status =
Ady Abraham285f8c12022-10-11 17:12:14 -07002867 ComposerServiceAIDL::getComposerService()->setDesiredDisplayModeSpecs(displayToken,
2868 specs);
Huihong Luo3bdef862022-03-03 11:57:19 -08002869 return statusTFromBinderStatus(status);
Ana Krulec0782b882019-10-15 17:34:54 -07002870}
2871
Marin Shalamanov228f46b2021-01-28 21:11:45 +01002872status_t SurfaceComposerClient::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -07002873 gui::DisplayModeSpecs* outSpecs) {
2874 if (!outSpecs) {
Huihong Luo02186fb2022-02-23 14:21:54 -08002875 return BAD_VALUE;
2876 }
Huihong Luo02186fb2022-02-23 14:21:54 -08002877 binder::Status status =
2878 ComposerServiceAIDL::getComposerService()->getDesiredDisplayModeSpecs(displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -07002879 outSpecs);
Huihong Luo3bdef862022-03-03 11:57:19 -08002880 return statusTFromBinderStatus(status);
Ana Krulec234bb162019-11-10 22:55:55 +01002881}
2882
Daniel Solomon42d04562019-01-20 21:03:19 -08002883status_t SurfaceComposerClient::getDisplayNativePrimaries(const sp<IBinder>& display,
2884 ui::DisplayPrimaries& outPrimaries) {
Huihong Luoca3d9a42022-02-22 11:07:34 -08002885 gui::DisplayPrimaries primaries;
2886 binder::Status status =
2887 ComposerServiceAIDL::getComposerService()->getDisplayNativePrimaries(display,
2888 &primaries);
2889 if (status.isOk()) {
2890 outPrimaries.red.X = primaries.red.X;
2891 outPrimaries.red.Y = primaries.red.Y;
2892 outPrimaries.red.Z = primaries.red.Z;
2893
2894 outPrimaries.green.X = primaries.green.X;
2895 outPrimaries.green.Y = primaries.green.Y;
2896 outPrimaries.green.Z = primaries.green.Z;
2897
2898 outPrimaries.blue.X = primaries.blue.X;
2899 outPrimaries.blue.Y = primaries.blue.Y;
2900 outPrimaries.blue.Z = primaries.blue.Z;
2901
2902 outPrimaries.white.X = primaries.white.X;
2903 outPrimaries.white.Y = primaries.white.Y;
2904 outPrimaries.white.Z = primaries.white.Z;
2905 }
Huihong Luo3bdef862022-03-03 11:57:19 -08002906 return statusTFromBinderStatus(status);
Daniel Solomon42d04562019-01-20 21:03:19 -08002907}
2908
Michael Wright28f24d02016-07-12 13:30:53 -07002909status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display,
Peiyong Lina52f0292018-03-14 17:26:31 -07002910 ColorMode colorMode) {
Huihong Luoca3d9a42022-02-22 11:07:34 -08002911 binder::Status status = ComposerServiceAIDL::getComposerService()
2912 ->setActiveColorMode(display, static_cast<int>(colorMode));
Huihong Luo3bdef862022-03-03 11:57:19 -08002913 return statusTFromBinderStatus(status);
Michael Wright28f24d02016-07-12 13:30:53 -07002914}
2915
Kriti Dang7defaf32021-11-15 11:55:43 +01002916status_t SurfaceComposerClient::getBootDisplayModeSupport(bool* support) {
Huihong Luo37396db2022-02-15 10:43:00 -08002917 binder::Status status =
2918 ComposerServiceAIDL::getComposerService()->getBootDisplayModeSupport(support);
Huihong Luo3bdef862022-03-03 11:57:19 -08002919 return statusTFromBinderStatus(status);
Kriti Dang7defaf32021-11-15 11:55:43 +01002920}
2921
Sally Qi0cbd08b2022-08-17 12:12:28 -07002922status_t SurfaceComposerClient::getOverlaySupport(gui::OverlayProperties* outProperties) {
2923 binder::Status status =
2924 ComposerServiceAIDL::getComposerService()->getOverlaySupport(outProperties);
2925 return statusTFromBinderStatus(status);
2926}
2927
Kriti Dang7defaf32021-11-15 11:55:43 +01002928status_t SurfaceComposerClient::setBootDisplayMode(const sp<IBinder>& display,
2929 ui::DisplayModeId displayModeId) {
Huihong Luoca3d9a42022-02-22 11:07:34 -08002930 binder::Status status = ComposerServiceAIDL::getComposerService()
2931 ->setBootDisplayMode(display, static_cast<int>(displayModeId));
Huihong Luo3bdef862022-03-03 11:57:19 -08002932 return statusTFromBinderStatus(status);
Kriti Dang7defaf32021-11-15 11:55:43 +01002933}
2934
2935status_t SurfaceComposerClient::clearBootDisplayMode(const sp<IBinder>& display) {
Huihong Luo37396db2022-02-15 10:43:00 -08002936 binder::Status status =
2937 ComposerServiceAIDL::getComposerService()->clearBootDisplayMode(display);
Huihong Luo3bdef862022-03-03 11:57:19 -08002938 return statusTFromBinderStatus(status);
Kriti Dang7defaf32021-11-15 11:55:43 +01002939}
2940
Kriti Dang674b9372022-11-18 10:58:44 +01002941status_t SurfaceComposerClient::getHdrConversionCapabilities(
2942 std::vector<gui::HdrConversionCapability>* hdrConversionCapabilities) {
2943 binder::Status status = ComposerServiceAIDL::getComposerService()->getHdrConversionCapabilities(
2944 hdrConversionCapabilities);
2945 return statusTFromBinderStatus(status);
2946}
2947
2948status_t SurfaceComposerClient::setHdrConversionStrategy(
Kriti Dangd432bb52023-02-09 18:21:04 +01002949 gui::HdrConversionStrategy hdrConversionStrategy, ui::Hdr* outPreferredHdrOutputType) {
2950 int hdrType;
2951 binder::Status status = ComposerServiceAIDL::getComposerService()
2952 ->setHdrConversionStrategy(hdrConversionStrategy, &hdrType);
2953 *outPreferredHdrOutputType = static_cast<ui::Hdr>(hdrType);
Kriti Dang674b9372022-11-18 10:58:44 +01002954 return statusTFromBinderStatus(status);
2955}
2956
Kriti Dangafd1fda2023-01-17 13:33:15 +01002957status_t SurfaceComposerClient::getHdrOutputConversionSupport(bool* isSupported) {
2958 binder::Status status =
2959 ComposerServiceAIDL::getComposerService()->getHdrOutputConversionSupport(isSupported);
2960 return statusTFromBinderStatus(status);
2961}
2962
Andy Yu8c2703d2023-11-03 11:22:46 -07002963status_t SurfaceComposerClient::setGameModeFrameRateOverride(uid_t uid, float frameRate) {
Huihong Luo3bdef862022-03-03 11:57:19 -08002964 binder::Status status =
Andy Yu8c2703d2023-11-03 11:22:46 -07002965 ComposerServiceAIDL::getComposerService()->setGameModeFrameRateOverride(uid, frameRate);
2966 return statusTFromBinderStatus(status);
2967}
2968
2969status_t SurfaceComposerClient::setGameDefaultFrameRateOverride(uid_t uid, float frameRate) {
2970 binder::Status status =
2971 ComposerServiceAIDL::getComposerService()->setGameDefaultFrameRateOverride(uid,
2972 frameRate);
Huihong Luo3bdef862022-03-03 11:57:19 -08002973 return statusTFromBinderStatus(status);
Andy Yu2ae6b6b2021-11-18 14:51:06 -08002974}
2975
Tony Huangf3621102023-09-04 17:14:22 +08002976status_t SurfaceComposerClient::updateSmallAreaDetection(std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00002977 std::vector<float>& thresholds) {
2978 binder::Status status =
Tony Huangf3621102023-09-04 17:14:22 +08002979 ComposerServiceAIDL::getComposerService()->updateSmallAreaDetection(appIds, thresholds);
Tony Huang9ac5e6e2023-08-24 09:01:44 +00002980 return statusTFromBinderStatus(status);
2981}
2982
Tony Huangf3621102023-09-04 17:14:22 +08002983status_t SurfaceComposerClient::setSmallAreaDetectionThreshold(int32_t appId, float threshold) {
Tony Huang9ac5e6e2023-08-24 09:01:44 +00002984 binder::Status status =
Tony Huangf3621102023-09-04 17:14:22 +08002985 ComposerServiceAIDL::getComposerService()->setSmallAreaDetectionThreshold(appId,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00002986 threshold);
2987 return statusTFromBinderStatus(status);
2988}
2989
Galia Peycheva5492cb52019-10-30 14:13:16 +01002990void SurfaceComposerClient::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
Huihong Luo37396db2022-02-15 10:43:00 -08002991 ComposerServiceAIDL::getComposerService()->setAutoLowLatencyMode(display, on);
Galia Peycheva5492cb52019-10-30 14:13:16 +01002992}
2993
Galia Peycheva5492cb52019-10-30 14:13:16 +01002994void SurfaceComposerClient::setGameContentType(const sp<IBinder>& display, bool on) {
Huihong Luo37396db2022-02-15 10:43:00 -08002995 ComposerServiceAIDL::getComposerService()->setGameContentType(display, on);
Galia Peycheva5492cb52019-10-30 14:13:16 +01002996}
2997
Prashant Malani2c9b11f2014-05-25 01:36:31 -07002998void SurfaceComposerClient::setDisplayPowerMode(const sp<IBinder>& token,
2999 int mode) {
Huihong Luo37396db2022-02-15 10:43:00 -08003000 ComposerServiceAIDL::getComposerService()->setPowerMode(token, mode);
Jeff Brown2a09bb32012-10-08 19:13:57 -07003001}
3002
Peiyong Linc6780972018-10-28 15:24:08 -07003003status_t SurfaceComposerClient::getCompositionPreference(
3004 ui::Dataspace* defaultDataspace, ui::PixelFormat* defaultPixelFormat,
3005 ui::Dataspace* wideColorGamutDataspace, ui::PixelFormat* wideColorGamutPixelFormat) {
Huihong Luo05539a12022-02-23 10:29:40 -08003006 gui::CompositionPreference pref;
3007 binder::Status status =
3008 ComposerServiceAIDL::getComposerService()->getCompositionPreference(&pref);
3009 if (status.isOk()) {
3010 *defaultDataspace = static_cast<ui::Dataspace>(pref.defaultDataspace);
3011 *defaultPixelFormat = static_cast<ui::PixelFormat>(pref.defaultPixelFormat);
3012 *wideColorGamutDataspace = static_cast<ui::Dataspace>(pref.wideColorGamutDataspace);
3013 *wideColorGamutPixelFormat = static_cast<ui::PixelFormat>(pref.wideColorGamutPixelFormat);
3014 }
Huihong Luo3bdef862022-03-03 11:57:19 -08003015 return statusTFromBinderStatus(status);
Peiyong Lin0256f722018-08-31 15:45:10 -07003016}
3017
Peiyong Lin08d10512019-01-16 13:27:35 -08003018bool SurfaceComposerClient::getProtectedContentSupport() {
3019 bool supported = false;
Huihong Luo05539a12022-02-23 10:29:40 -08003020 ComposerServiceAIDL::getComposerService()->getProtectedContentSupport(&supported);
Peiyong Lin08d10512019-01-16 13:27:35 -08003021 return supported;
3022}
3023
Svetoslavd85084b2014-03-20 10:28:31 -07003024status_t SurfaceComposerClient::clearAnimationFrameStats() {
Huihong Luo4ed1c912022-02-22 14:30:01 -08003025 binder::Status status = ComposerServiceAIDL::getComposerService()->clearAnimationFrameStats();
Huihong Luo3bdef862022-03-03 11:57:19 -08003026 return statusTFromBinderStatus(status);
Svetoslavd85084b2014-03-20 10:28:31 -07003027}
3028
3029status_t SurfaceComposerClient::getAnimationFrameStats(FrameStats* outStats) {
Huihong Luo4ed1c912022-02-22 14:30:01 -08003030 gui::FrameStats stats;
3031 binder::Status status =
3032 ComposerServiceAIDL::getComposerService()->getAnimationFrameStats(&stats);
3033 if (status.isOk()) {
3034 outStats->refreshPeriodNano = stats.refreshPeriodNano;
3035 outStats->desiredPresentTimesNano.setCapacity(stats.desiredPresentTimesNano.size());
3036 for (const auto& t : stats.desiredPresentTimesNano) {
3037 outStats->desiredPresentTimesNano.add(t);
3038 }
3039 outStats->actualPresentTimesNano.setCapacity(stats.actualPresentTimesNano.size());
3040 for (const auto& t : stats.actualPresentTimesNano) {
3041 outStats->actualPresentTimesNano.add(t);
3042 }
3043 outStats->frameReadyTimesNano.setCapacity(stats.frameReadyTimesNano.size());
3044 for (const auto& t : stats.frameReadyTimesNano) {
3045 outStats->frameReadyTimesNano.add(t);
3046 }
3047 }
Huihong Luo3bdef862022-03-03 11:57:19 -08003048 return statusTFromBinderStatus(status);
Svetoslavd85084b2014-03-20 10:28:31 -07003049}
3050
Kriti Dang49ad4132021-01-08 11:49:56 +01003051status_t SurfaceComposerClient::overrideHdrTypes(const sp<IBinder>& display,
3052 const std::vector<ui::Hdr>& hdrTypes) {
Huihong Luo05539a12022-02-23 10:29:40 -08003053 std::vector<int32_t> hdrTypesVector;
3054 hdrTypesVector.reserve(hdrTypes.size());
3055 for (auto t : hdrTypes) {
3056 hdrTypesVector.push_back(static_cast<int32_t>(t));
3057 }
3058
3059 binder::Status status =
3060 ComposerServiceAIDL::getComposerService()->overrideHdrTypes(display, hdrTypesVector);
Huihong Luo3bdef862022-03-03 11:57:19 -08003061 return statusTFromBinderStatus(status);
Kriti Dang49ad4132021-01-08 11:49:56 +01003062}
3063
Tej Singhe2751772021-04-06 22:05:29 -07003064status_t SurfaceComposerClient::onPullAtom(const int32_t atomId, std::string* outData,
3065 bool* success) {
Huihong Luo05539a12022-02-23 10:29:40 -08003066 gui::PullAtomData pad;
3067 binder::Status status = ComposerServiceAIDL::getComposerService()->onPullAtom(atomId, &pad);
3068 if (status.isOk()) {
Huihong Luo30aa4372022-10-03 14:54:12 -07003069 outData->assign(pad.data.begin(), pad.data.end());
Huihong Luo05539a12022-02-23 10:29:40 -08003070 *success = pad.success;
3071 }
Huihong Luo3bdef862022-03-03 11:57:19 -08003072 return statusTFromBinderStatus(status);
Tej Singhe2751772021-04-06 22:05:29 -07003073}
3074
Kevin DuBois9c0a1762018-10-16 13:32:31 -07003075status_t SurfaceComposerClient::getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
3076 ui::PixelFormat* outFormat,
3077 ui::Dataspace* outDataspace,
3078 uint8_t* outComponentMask) {
Huihong Luo05539a12022-02-23 10:29:40 -08003079 if (!outFormat || !outDataspace || !outComponentMask) {
3080 return BAD_VALUE;
3081 }
3082
3083 gui::ContentSamplingAttributes attrs;
3084 binder::Status status = ComposerServiceAIDL::getComposerService()
3085 ->getDisplayedContentSamplingAttributes(display, &attrs);
3086 if (status.isOk()) {
3087 *outFormat = static_cast<ui::PixelFormat>(attrs.format);
3088 *outDataspace = static_cast<ui::Dataspace>(attrs.dataspace);
3089 *outComponentMask = static_cast<uint8_t>(attrs.componentMask);
3090 }
Huihong Luo3bdef862022-03-03 11:57:19 -08003091 return statusTFromBinderStatus(status);
Kevin DuBois9c0a1762018-10-16 13:32:31 -07003092}
3093
Kevin DuBois74e53772018-11-19 10:52:38 -08003094status_t SurfaceComposerClient::setDisplayContentSamplingEnabled(const sp<IBinder>& display,
3095 bool enable, uint8_t componentMask,
3096 uint64_t maxFrames) {
Huihong Luo05539a12022-02-23 10:29:40 -08003097 binder::Status status =
3098 ComposerServiceAIDL::getComposerService()
3099 ->setDisplayContentSamplingEnabled(display, enable,
3100 static_cast<int8_t>(componentMask),
3101 static_cast<int64_t>(maxFrames));
Huihong Luo3bdef862022-03-03 11:57:19 -08003102 return statusTFromBinderStatus(status);
Kevin DuBois74e53772018-11-19 10:52:38 -08003103}
3104
Kevin DuBois1d4249a2018-08-29 10:45:14 -07003105status_t SurfaceComposerClient::getDisplayedContentSample(const sp<IBinder>& display,
3106 uint64_t maxFrames, uint64_t timestamp,
3107 DisplayedFrameStats* outStats) {
Huihong Luo3bdef862022-03-03 11:57:19 -08003108 if (!outStats) {
3109 return BAD_VALUE;
3110 }
3111
3112 gui::DisplayedFrameStats stats;
3113 binder::Status status =
3114 ComposerServiceAIDL::getComposerService()->getDisplayedContentSample(display, maxFrames,
3115 timestamp, &stats);
3116 if (status.isOk()) {
3117 // convert gui::DisplayedFrameStats to ui::DisplayedFrameStats
3118 outStats->numFrames = static_cast<uint64_t>(stats.numFrames);
3119 outStats->component_0_sample.reserve(stats.component_0_sample.size());
3120 for (const auto& s : stats.component_0_sample) {
3121 outStats->component_0_sample.push_back(static_cast<uint64_t>(s));
3122 }
3123 outStats->component_1_sample.reserve(stats.component_1_sample.size());
3124 for (const auto& s : stats.component_1_sample) {
3125 outStats->component_1_sample.push_back(static_cast<uint64_t>(s));
3126 }
3127 outStats->component_2_sample.reserve(stats.component_2_sample.size());
3128 for (const auto& s : stats.component_2_sample) {
3129 outStats->component_2_sample.push_back(static_cast<uint64_t>(s));
3130 }
3131 outStats->component_3_sample.reserve(stats.component_3_sample.size());
3132 for (const auto& s : stats.component_3_sample) {
3133 outStats->component_3_sample.push_back(static_cast<uint64_t>(s));
3134 }
3135 }
3136 return statusTFromBinderStatus(status);
Kevin DuBois1d4249a2018-08-29 10:45:14 -07003137}
Marissa Wall35187b32019-01-08 10:08:52 -08003138
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08003139status_t SurfaceComposerClient::isWideColorDisplay(const sp<IBinder>& display,
3140 bool* outIsWideColorDisplay) {
Huihong Luo37396db2022-02-15 10:43:00 -08003141 binder::Status status =
3142 ComposerServiceAIDL::getComposerService()->isWideColorDisplay(display,
3143 outIsWideColorDisplay);
Huihong Luo3bdef862022-03-03 11:57:19 -08003144 return statusTFromBinderStatus(status);
Peiyong Lin4f3fddf2019-01-24 17:21:24 -08003145}
3146
Kevin DuBois00c66832019-02-18 16:21:31 -08003147status_t SurfaceComposerClient::addRegionSamplingListener(
3148 const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
3149 const sp<IRegionSamplingListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003150 gui::ARect rect;
3151 rect.left = samplingArea.left;
3152 rect.top = samplingArea.top;
3153 rect.right = samplingArea.right;
3154 rect.bottom = samplingArea.bottom;
3155 binder::Status status =
3156 ComposerServiceAIDL::getComposerService()->addRegionSamplingListener(rect,
3157 stopLayerHandle,
3158 listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003159 return statusTFromBinderStatus(status);
Kevin DuBois00c66832019-02-18 16:21:31 -08003160}
3161
3162status_t SurfaceComposerClient::removeRegionSamplingListener(
3163 const sp<IRegionSamplingListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003164 binder::Status status =
3165 ComposerServiceAIDL::getComposerService()->removeRegionSamplingListener(listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003166 return statusTFromBinderStatus(status);
Kevin DuBois00c66832019-02-18 16:21:31 -08003167}
3168
Alec Mouria9a68a62021-03-04 19:14:50 -08003169status_t SurfaceComposerClient::addFpsListener(int32_t taskId,
Alec Mouriadebf5c2021-01-05 12:57:36 -08003170 const sp<gui::IFpsListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003171 binder::Status status =
3172 ComposerServiceAIDL::getComposerService()->addFpsListener(taskId, listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003173 return statusTFromBinderStatus(status);
Alec Mouriadebf5c2021-01-05 12:57:36 -08003174}
3175
3176status_t SurfaceComposerClient::removeFpsListener(const sp<gui::IFpsListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003177 binder::Status status = ComposerServiceAIDL::getComposerService()->removeFpsListener(listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003178 return statusTFromBinderStatus(status);
Alec Mouriadebf5c2021-01-05 12:57:36 -08003179}
3180
Galia Peycheva8f04b302021-04-27 13:25:38 +02003181status_t SurfaceComposerClient::addTunnelModeEnabledListener(
3182 const sp<gui::ITunnelModeEnabledListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003183 binder::Status status =
3184 ComposerServiceAIDL::getComposerService()->addTunnelModeEnabledListener(listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003185 return statusTFromBinderStatus(status);
Galia Peycheva8f04b302021-04-27 13:25:38 +02003186}
3187
3188status_t SurfaceComposerClient::removeTunnelModeEnabledListener(
3189 const sp<gui::ITunnelModeEnabledListener>& listener) {
Huihong Luo02186fb2022-02-23 14:21:54 -08003190 binder::Status status =
3191 ComposerServiceAIDL::getComposerService()->removeTunnelModeEnabledListener(listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003192 return statusTFromBinderStatus(status);
Galia Peycheva8f04b302021-04-27 13:25:38 +02003193}
3194
Dan Gittik57e63c52019-01-18 16:37:54 +00003195bool SurfaceComposerClient::getDisplayBrightnessSupport(const sp<IBinder>& displayToken) {
3196 bool support = false;
Huihong Luo37396db2022-02-15 10:43:00 -08003197 binder::Status status =
3198 ComposerServiceAIDL::getComposerService()->getDisplayBrightnessSupport(displayToken,
3199 &support);
3200 return status.isOk() ? support : false;
Dan Gittik57e63c52019-01-18 16:37:54 +00003201}
3202
3203status_t SurfaceComposerClient::setDisplayBrightness(const sp<IBinder>& displayToken,
John Reck22be6962021-03-10 12:59:54 -05003204 const gui::DisplayBrightness& brightness) {
Huihong Luo37396db2022-02-15 10:43:00 -08003205 binder::Status status =
3206 ComposerServiceAIDL::getComposerService()->setDisplayBrightness(displayToken,
3207 brightness);
Huihong Luo3bdef862022-03-03 11:57:19 -08003208 return statusTFromBinderStatus(status);
Dan Gittik57e63c52019-01-18 16:37:54 +00003209}
3210
John Reck88270902021-03-18 11:27:35 -04003211status_t SurfaceComposerClient::addHdrLayerInfoListener(
3212 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
Huihong Luo37396db2022-02-15 10:43:00 -08003213 binder::Status status =
3214 ComposerServiceAIDL::getComposerService()->addHdrLayerInfoListener(displayToken,
3215 listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003216 return statusTFromBinderStatus(status);
John Reck88270902021-03-18 11:27:35 -04003217}
3218
3219status_t SurfaceComposerClient::removeHdrLayerInfoListener(
3220 const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
Huihong Luo37396db2022-02-15 10:43:00 -08003221 binder::Status status =
3222 ComposerServiceAIDL::getComposerService()->removeHdrLayerInfoListener(displayToken,
3223 listener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003224 return statusTFromBinderStatus(status);
John Reck88270902021-03-18 11:27:35 -04003225}
3226
Lais Andrade3a6e47d2020-04-02 11:20:16 +01003227status_t SurfaceComposerClient::notifyPowerBoost(int32_t boostId) {
Huihong Luo37396db2022-02-15 10:43:00 -08003228 binder::Status status = ComposerServiceAIDL::getComposerService()->notifyPowerBoost(boostId);
Huihong Luo3bdef862022-03-03 11:57:19 -08003229 return statusTFromBinderStatus(status);
Ady Abraham8532d012019-05-08 14:50:56 -07003230}
3231
Vishnu Nairb13bb952019-11-15 10:24:08 -08003232status_t SurfaceComposerClient::setGlobalShadowSettings(const half4& ambientColor,
3233 const half4& spotColor, float lightPosY,
3234 float lightPosZ, float lightRadius) {
Huihong Luo3bdef862022-03-03 11:57:19 -08003235 gui::Color ambientColorG, spotColorG;
3236 ambientColorG.r = ambientColor.r;
3237 ambientColorG.g = ambientColor.g;
3238 ambientColorG.b = ambientColor.b;
3239 ambientColorG.a = ambientColor.a;
3240 spotColorG.r = spotColor.r;
3241 spotColorG.g = spotColor.g;
3242 spotColorG.b = spotColor.b;
3243 spotColorG.a = spotColor.a;
3244 binder::Status status =
3245 ComposerServiceAIDL::getComposerService()->setGlobalShadowSettings(ambientColorG,
3246 spotColorG,
3247 lightPosY, lightPosZ,
3248 lightRadius);
3249 return statusTFromBinderStatus(status);
Vishnu Nairb13bb952019-11-15 10:24:08 -08003250}
3251
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05003252std::optional<DisplayDecorationSupport> SurfaceComposerClient::getDisplayDecorationSupport(
3253 const sp<IBinder>& displayToken) {
Huihong Luo3bdef862022-03-03 11:57:19 -08003254 std::optional<gui::DisplayDecorationSupport> gsupport;
3255 binder::Status status =
3256 ComposerServiceAIDL::getComposerService()->getDisplayDecorationSupport(displayToken,
3257 &gsupport);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -05003258 std::optional<DisplayDecorationSupport> support;
Leon Scroggins III9a11a2e2022-10-04 12:46:21 -04003259 if (status.isOk() && gsupport.has_value()) {
Leon Scroggins III0f365ab2022-08-03 15:35:40 -04003260 support.emplace(DisplayDecorationSupport{
3261 .format =
3262 static_cast<aidl::android::hardware::graphics::common::PixelFormat>(
3263 gsupport->format),
3264 .alphaInterpretation =
Huihong Luo3bdef862022-03-03 11:57:19 -08003265 static_cast<aidl::android::hardware::graphics::common::AlphaInterpretation>(
Leon Scroggins III0f365ab2022-08-03 15:35:40 -04003266 gsupport->alphaInterpretation)
3267 });
Huihong Luo3bdef862022-03-03 11:57:19 -08003268 }
Leon Scroggins IIIe5cff632021-12-29 11:53:36 -05003269 return support;
3270}
3271
Huihong Luo02186fb2022-02-23 14:21:54 -08003272int SurfaceComposerClient::getGpuContextPriority() {
3273 int priority;
3274 binder::Status status =
3275 ComposerServiceAIDL::getComposerService()->getGpuContextPriority(&priority);
3276 if (!status.isOk()) {
Huihong Luo3bdef862022-03-03 11:57:19 -08003277 status_t err = statusTFromBinderStatus(status);
Huihong Luo02186fb2022-02-23 14:21:54 -08003278 ALOGE("getGpuContextPriority failed to read data: %s (%d)", strerror(-err), err);
3279 return 0;
3280 }
3281 return priority;
Ana Krulec31f2b3c2020-12-14 14:30:09 -08003282}
3283
chaviw60c9d3e2021-06-04 12:52:17 -05003284status_t SurfaceComposerClient::addWindowInfosListener(
chaviwa2948ad2022-03-08 11:07:01 -06003285 const sp<WindowInfosListener>& windowInfosListener,
3286 std::pair<std::vector<gui::WindowInfo>, std::vector<gui::DisplayInfo>>* outInitialInfo) {
chaviw60c9d3e2021-06-04 12:52:17 -05003287 return WindowInfosListenerReporter::getInstance()
Huihong Luo02186fb2022-02-23 14:21:54 -08003288 ->addWindowInfosListener(windowInfosListener, ComposerServiceAIDL::getComposerService(),
chaviwa2948ad2022-03-08 11:07:01 -06003289 outInitialInfo);
chaviw60c9d3e2021-06-04 12:52:17 -05003290}
3291
3292status_t SurfaceComposerClient::removeWindowInfosListener(
3293 const sp<WindowInfosListener>& windowInfosListener) {
3294 return WindowInfosListenerReporter::getInstance()
Huihong Luo02186fb2022-02-23 14:21:54 -08003295 ->removeWindowInfosListener(windowInfosListener,
3296 ComposerServiceAIDL::getComposerService());
chaviw60c9d3e2021-06-04 12:52:17 -05003297}
Wenhui Yangeafc18a2024-05-14 17:15:52 +00003298
3299void SurfaceComposerClient::notifyShutdown() {
3300 ComposerServiceAIDL::getComposerService()->notifyShutdown();
3301}
Mathias Agopian698c0872011-06-28 19:09:31 -07003302// ----------------------------------------------------------------------------
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08003303
chaviw690db382020-07-27 16:46:46 -07003304status_t ScreenshotClient::captureDisplay(const DisplayCaptureArgs& captureArgs,
chaviwe7b9f272020-08-18 16:08:59 -07003305 const sp<IScreenCaptureListener>& captureListener) {
Huihong Luof5029222021-12-16 14:33:46 -08003306 sp<gui::ISurfaceComposer> s(ComposerServiceAIDL::getComposerService());
Yi Kong48a619f2018-06-05 16:34:59 -07003307 if (s == nullptr) return NO_INIT;
chaviw8ffc7b82020-08-18 11:25:37 -07003308
Huihong Luof5029222021-12-16 14:33:46 -08003309 binder::Status status = s->captureDisplay(captureArgs, captureListener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003310 return statusTFromBinderStatus(status);
Robert Carr673134e2017-01-09 19:48:38 -08003311}
3312
John Reck7e4c4872023-11-14 18:31:03 -05003313status_t ScreenshotClient::captureDisplay(DisplayId displayId, const gui::CaptureArgs& captureArgs,
chaviwe7b9f272020-08-18 16:08:59 -07003314 const sp<IScreenCaptureListener>& captureListener) {
Huihong Luof5029222021-12-16 14:33:46 -08003315 sp<gui::ISurfaceComposer> s(ComposerServiceAIDL::getComposerService());
chaviw93df2ea2019-04-30 16:45:12 -07003316 if (s == nullptr) return NO_INIT;
chaviw8ffc7b82020-08-18 11:25:37 -07003317
John Reck7e4c4872023-11-14 18:31:03 -05003318 binder::Status status = s->captureDisplayById(displayId.value, captureArgs, captureListener);
Huihong Luo3bdef862022-03-03 11:57:19 -08003319 return statusTFromBinderStatus(status);
chaviw93df2ea2019-04-30 16:45:12 -07003320}
3321
chaviw26c52482020-07-28 16:25:52 -07003322status_t ScreenshotClient::captureLayers(const LayerCaptureArgs& captureArgs,
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00003323 const sp<IScreenCaptureListener>& captureListener,
3324 bool sync) {
Huihong Luof5029222021-12-16 14:33:46 -08003325 sp<gui::ISurfaceComposer> s(ComposerServiceAIDL::getComposerService());
Yi Kong48a619f2018-06-05 16:34:59 -07003326 if (s == nullptr) return NO_INIT;
chaviw8ffc7b82020-08-18 11:25:37 -07003327
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00003328 binder::Status status;
3329 if (sync) {
3330 gui::ScreenCaptureResults captureResults;
3331 status = s->captureLayersSync(captureArgs, &captureResults);
3332 captureListener->onScreenCaptureCompleted(captureResults);
3333 } else {
3334 status = s->captureLayers(captureArgs, captureListener);
3335 }
Huihong Luo3bdef862022-03-03 11:57:19 -08003336 return statusTFromBinderStatus(status);
chaviwa76b2712017-09-20 12:02:26 -07003337}
Dominik Laskowski718f9602019-11-09 20:01:35 -08003338
chaviw69058fb2021-09-27 09:37:30 -05003339// ---------------------------------------------------------------------------------
3340
3341void ReleaseCallbackThread::addReleaseCallback(const ReleaseCallbackId callbackId,
3342 sp<Fence> releaseFence) {
3343 std::scoped_lock<std::mutex> lock(mMutex);
3344 if (!mStarted) {
3345 mThread = std::thread(&ReleaseCallbackThread::threadMain, this);
3346 mStarted = true;
3347 }
3348
3349 mCallbackInfos.emplace(callbackId, std::move(releaseFence));
3350 mReleaseCallbackPending.notify_one();
3351}
3352
3353void ReleaseCallbackThread::threadMain() {
3354 const auto listener = TransactionCompletedListener::getInstance();
3355 std::queue<std::tuple<const ReleaseCallbackId, const sp<Fence>>> callbackInfos;
3356 while (true) {
3357 {
3358 std::unique_lock<std::mutex> lock(mMutex);
Chavi Weingartene0237bb2023-02-06 21:48:32 +00003359 base::ScopedLockAssertion assumeLocked(mMutex);
chaviw69058fb2021-09-27 09:37:30 -05003360 callbackInfos = std::move(mCallbackInfos);
3361 mCallbackInfos = {};
3362 }
3363
3364 while (!callbackInfos.empty()) {
3365 auto [callbackId, releaseFence] = callbackInfos.front();
Huihong Luoffee3bc2023-01-17 16:14:35 +00003366 listener->onReleaseBuffer(callbackId, std::move(releaseFence), UINT_MAX);
chaviw69058fb2021-09-27 09:37:30 -05003367 callbackInfos.pop();
3368 }
3369
3370 {
3371 std::unique_lock<std::mutex> lock(mMutex);
Chavi Weingartene0237bb2023-02-06 21:48:32 +00003372 base::ScopedLockAssertion assumeLocked(mMutex);
chaviw69058fb2021-09-27 09:37:30 -05003373 if (mCallbackInfos.size() == 0) {
3374 mReleaseCallbackPending.wait(lock);
3375 }
3376 }
3377 }
3378}
3379
Dominik Laskowski718f9602019-11-09 20:01:35 -08003380} // namespace android