blob: b12e3fb6266a94d73aabe48a4d047a1ad9a2edee [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
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080017// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
20
Dan Stoza9e56aa02015-11-02 13:00:03 -080021//#define LOG_NDEBUG 0
22#undef LOG_TAG
23#define LOG_TAG "Layer"
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080024#define ATRACE_TAG ATRACE_TAG_GRAPHICS
25
Alec Mourie60041e2019-06-14 18:59:51 -070026#include "Layer.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080027
[1;3C2b9fc252021-02-04 16:16:50 -080028#include <android-base/properties.h>
Yiwei Zhang5434a782018-12-05 18:06:32 -080029#include <android-base/stringprintf.h>
Steven Thomas62a4cf82020-01-31 12:04:03 -080030#include <android/native_window.h>
Vishnu Nair0f085c62019-08-30 08:49:12 -070031#include <binder/IPCThreadState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080032#include <compositionengine/Display.h>
Lloyd Piquea83776c2019-01-29 18:42:32 -080033#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080034#include <compositionengine/OutputLayer.h>
35#include <compositionengine/impl/OutputLayerCompositionState.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070036#include <cutils/compiler.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070037#include <cutils/native_handle.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070038#include <cutils/properties.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080039#include <gui/BufferItem.h>
40#include <gui/LayerDebugInfo.h>
41#include <gui/Surface.h>
Alec Mourie60041e2019-06-14 18:59:51 -070042#include <math.h>
chaviw250bcbb2020-08-05 11:17:54 -070043#include <private/android_filesystem_config.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080044#include <renderengine/RenderEngine.h>
Alec Mourie60041e2019-06-14 18:59:51 -070045#include <stdint.h>
46#include <stdlib.h>
47#include <sys/types.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080048#include <ui/DebugUtils.h>
49#include <ui/GraphicBuffer.h>
50#include <ui/PixelFormat.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080051#include <utils/Errors.h>
52#include <utils/Log.h>
Jesse Hall399184a2014-03-03 15:42:54 -080053#include <utils/NativeHandle.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080054#include <utils/StopWatch.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080055#include <utils/Trace.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080056
Alec Mourie60041e2019-06-14 18:59:51 -070057#include <algorithm>
58#include <mutex>
59#include <sstream>
60
Yiwei Zhang60d1a192018-03-07 14:52:28 -080061#include "BufferLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020062#include "Colorizer.h"
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -070063#include "DisplayDevice.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080064#include "DisplayHardware/HWComposer.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080065#include "EffectLayer.h"
Ady Abraham22c7b5c2020-09-22 19:33:40 -070066#include "FrameTimeline.h"
Mikael Pessa90092f42019-08-26 17:22:04 -070067#include "FrameTracer/FrameTracer.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080068#include "LayerProtoHelper.h"
Fabien Sanglard7b1563a2016-10-13 12:05:28 -070069#include "LayerRejecter.h"
Dan Stozab9b08832014-03-13 11:55:57 -070070#include "MonitoredProducer.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071#include "SurfaceFlinger.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080072#include "TimeStats/TimeStats.h"
Michael Wright44753b12020-07-08 13:48:11 +010073#include "input/InputWindow.h"
Mathias Agopian1b031492012-06-20 17:51:20 -070074
David Sodman41fdfc92017-11-06 16:09:56 -080075#define DEBUG_RESIZE 0
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080077namespace android {
Marin Shalamanov1876e2e2020-12-04 13:23:59 +010078namespace {
79constexpr int kDumpTableRowLength = 159;
80} // namespace
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080081
Yiwei Zhang5434a782018-12-05 18:06:32 -080082using base::StringAppendF;
Michael Wright44753b12020-07-08 13:48:11 +010083using namespace android::flag_operators;
Ady Abraham22c7b5c2020-09-22 19:33:40 -070084using PresentState = frametimeline::SurfaceFrame::PresentState;
Yiwei Zhang5434a782018-12-05 18:06:32 -080085
Lloyd Piquef1c675b2018-09-12 20:45:39 -070086std::atomic<int32_t> Layer::sSequence{1};
Mathias Agopian13127d82013-03-05 17:47:11 -080087
Lloyd Pique42ab75e2018-09-12 20:46:03 -070088Layer::Layer(const LayerCreationArgs& args)
Ady Abraham8f1ee7f2019-04-05 10:32:50 -070089 : mFlinger(args.flinger),
90 mName(args.name),
91 mClientRef(args.client),
Michael Wright44753b12020-07-08 13:48:11 +010092 mWindowType(static_cast<InputWindowInfo::Type>(
93 args.metadata.getInt32(METADATA_WINDOW_TYPE, 0))) {
Mathias Agopian4d9b8222013-03-12 17:11:48 -070094 uint32_t layerFlags = 0;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070095 if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
96 if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
97 if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;
chaviwc5676c62020-09-18 15:01:04 -070098 if (args.flags & ISurfaceComposerClient::eSkipScreenshot)
99 layerFlags |= layer_state_t::eLayerSkipScreenshot;
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700100
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800101 mCurrentState.active_legacy.w = args.w;
102 mCurrentState.active_legacy.h = args.h;
103 mCurrentState.flags = layerFlags;
104 mCurrentState.active_legacy.transform.set(0, 0);
chaviw25714502021-02-11 10:01:08 -0800105 mCurrentState.crop.makeInvalid();
106 mCurrentState.requestedCrop = mCurrentState.crop;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800107 mCurrentState.z = 0;
108 mCurrentState.color.a = 1.0f;
109 mCurrentState.layerStack = 0;
110 mCurrentState.sequence = 0;
111 mCurrentState.requested_legacy = mCurrentState.active_legacy;
chaviw766c9c52021-02-10 17:36:47 -0800112 mCurrentState.width = UINT32_MAX;
113 mCurrentState.height = UINT32_MAX;
114 mCurrentState.transform.set(0, 0);
Valerie Hau134651a2020-01-28 16:21:22 -0800115 mCurrentState.frameNumber = 0;
chaviw766c9c52021-02-10 17:36:47 -0800116 mCurrentState.bufferTransform = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800117 mCurrentState.transformToDisplayInverse = false;
118 mCurrentState.crop.makeInvalid();
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700119 mCurrentState.acquireFence = sp<Fence>::make(-1);
120 mCurrentState.acquireFenceTime = std::make_shared<FenceTime>(mCurrentState.acquireFence);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800121 mCurrentState.dataspace = ui::Dataspace::UNKNOWN;
122 mCurrentState.hdrMetadata.validTypes = 0;
Marissa Wall7e0a01f2019-08-14 14:29:25 -0700123 mCurrentState.surfaceDamageRegion = Region::INVALID_REGION;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800124 mCurrentState.cornerRadius = 0.0f;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800125 mCurrentState.backgroundBlurRadius = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800126 mCurrentState.api = -1;
127 mCurrentState.hasColorTransform = false;
Peiyong Linc502cb72019-03-01 15:00:23 -0800128 mCurrentState.colorSpaceAgnostic = false;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100129 mCurrentState.frameRateSelectionPriority = PRIORITY_UNSET;
Evan Roskya1f1e152019-01-24 16:17:46 -0800130 mCurrentState.metadata = args.metadata;
Vishnu Nairf37dcfb2019-11-16 07:37:09 -0800131 mCurrentState.shadowRadius = 0.f;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700132 mCurrentState.treeHasFrameRateVote = false;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700133 mCurrentState.fixedTransformHint = ui::Transform::ROT_INVALID;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000134 mCurrentState.frameTimelineInfo = {};
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700135 mCurrentState.postTime = -1;
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700136
Vishnu Nairc43a23c2020-05-29 14:32:27 -0700137 if (args.flags & ISurfaceComposerClient::eNoColorFill) {
138 // Set an invalid color so there is no color fill.
139 mCurrentState.color.r = -1.0_hf;
140 mCurrentState.color.g = -1.0_hf;
141 mCurrentState.color.b = -1.0_hf;
142 }
143
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700144 // drawing state & current state are identical
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800145 mDrawingState = mCurrentState;
Jamie Gennis6547ff42013-07-16 20:12:42 -0700146
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800147 CompositorTiming compositorTiming;
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700148 args.flinger->getCompositorTiming(&compositorTiming);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800149 mFrameEventHistory.initializeCompositorTiming(compositorTiming);
Jorim Jaggibd6480f2018-08-10 14:37:31 +0200150 mFrameTracker.setDisplayRefreshPeriod(compositorTiming.interval);
Robert Carr2e102c92018-10-23 12:11:15 -0700151
Vishnu Nair0f085c62019-08-30 08:49:12 -0700152 mCallingPid = args.callingPid;
153 mCallingUid = args.callingUid;
chaviw250bcbb2020-08-05 11:17:54 -0700154
155 if (mCallingUid == AID_GRAPHICS || mCallingUid == AID_SYSTEM) {
156 // If the system didn't send an ownerUid, use the callingUid for the ownerUid.
157 mOwnerUid = args.metadata.getInt32(METADATA_OWNER_UID, mCallingUid);
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700158 mOwnerPid = args.metadata.getInt32(METADATA_OWNER_PID, mCallingPid);
chaviw250bcbb2020-08-05 11:17:54 -0700159 } else {
160 // A create layer request from a non system request cannot specify the owner uid
161 mOwnerUid = mCallingUid;
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700162 mOwnerPid = mCallingPid;
chaviw250bcbb2020-08-05 11:17:54 -0700163 }
Dominik Laskowski75848362019-11-11 17:57:20 -0800164}
165
166void Layer::onFirstRef() {
167 mFlinger->onLayerFirstRef(this);
Dan Stoza436ccf32018-06-21 12:10:12 -0700168}
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700169
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700170Layer::~Layer() {
David Sodman577c8962017-12-08 14:50:53 -0800171 sp<Client> c(mClientRef.promote());
172 if (c != 0) {
173 c->detachLayer(this);
174 }
175
Jorim Jaggi10c985e2018-10-23 11:17:45 +0000176 mFrameTracker.logAndResetStats(mName);
chaviw74d90ad2019-04-26 14:45:26 -0700177 mFlinger->onLayerDestroyed(this);
Mathias Agopian96f08192010-06-02 23:28:45 -0700178}
179
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700180LayerCreationArgs::LayerCreationArgs(SurfaceFlinger* flinger, sp<Client> client, std::string name,
181 uint32_t w, uint32_t h, uint32_t flags, LayerMetadata metadata)
Vishnu Nair0f085c62019-08-30 08:49:12 -0700182 : flinger(flinger),
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700183 client(std::move(client)),
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700184 name(std::move(name)),
Vishnu Nair0f085c62019-08-30 08:49:12 -0700185 w(w),
186 h(h),
187 flags(flags),
188 metadata(std::move(metadata)) {
189 IPCThreadState* ipc = IPCThreadState::self();
190 callingPid = ipc->getCallingPid();
191 callingUid = ipc->getCallingUid();
192}
193
Mathias Agopian13127d82013-03-05 17:47:11 -0800194// ---------------------------------------------------------------------------
195// callbacks
196// ---------------------------------------------------------------------------
197
David Sodmaneb085e02017-10-05 18:49:04 -0700198/*
199 * onLayerDisplayed is only meaningful for BufferLayer, but, is called through
200 * Layer. So, the implementation is done in BufferLayer. When called on a
Vishnu Nairfa247b12020-02-11 08:58:26 -0800201 * EffectLayer object, it's essentially a NOP.
David Sodmaneb085e02017-10-05 18:49:04 -0700202 */
David Sodmaneb085e02017-10-05 18:49:04 -0700203void Layer::onLayerDisplayed(const sp<Fence>& /*releaseFence*/) {}
Mathias Agopian13127d82013-03-05 17:47:11 -0800204
chaviw43cb3cb2019-05-31 15:23:41 -0700205void Layer::removeRemoteSyncPoints() {
206 for (auto& point : mRemoteSyncPoints) {
207 point->setTransactionApplied();
208 }
209 mRemoteSyncPoints.clear();
210
211 {
chaviw43cb3cb2019-05-31 15:23:41 -0700212 for (State pendingState : mPendingStates) {
213 pendingState.barrierLayer_legacy = nullptr;
214 }
215 }
216}
217
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700218void Layer::removeRelativeZ(const std::vector<Layer*>& layersInTree) {
219 if (mCurrentState.zOrderRelativeOf == nullptr) {
220 return;
221 }
Robert Carr2e102c92018-10-23 12:11:15 -0700222
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700223 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
224 if (strongRelative == nullptr) {
225 setZOrderRelativeOf(nullptr);
226 return;
227 }
228
229 if (!std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
230 strongRelative->removeZOrderRelative(this);
231 mFlinger->setTransactionFlags(eTraversalNeeded);
chaviw606e5cf2019-03-01 10:12:10 -0800232 setZOrderRelativeOf(nullptr);
Robert Carr5edb1ad2017-04-25 10:54:24 -0700233 }
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700234}
235
236void Layer::removeFromCurrentState() {
237 mRemovedFromCurrentState = true;
Rob Carr4bba3702018-10-08 21:53:30 +0000238
Robert Carr2e102c92018-10-23 12:11:15 -0700239 // Since we are no longer reachable from CurrentState SurfaceFlinger
240 // will no longer invoke doTransaction for us, and so we will
241 // never finish applying transactions. We signal the sync point
242 // now so that another layer will not become indefinitely
243 // blocked.
chaviw43cb3cb2019-05-31 15:23:41 -0700244 removeRemoteSyncPoints();
Robert Carr2e102c92018-10-23 12:11:15 -0700245
246 {
247 Mutex::Autolock syncLock(mLocalSyncPointMutex);
248 for (auto& point : mLocalSyncPoints) {
249 point->setFrameAvailable();
250 }
251 mLocalSyncPoints.clear();
252 }
253
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800254 mFlinger->markLayerPendingRemovalLocked(this);
Chia-I Wuc6657022017-08-15 11:18:17 -0700255}
Chia-I Wu38512252017-05-17 14:36:16 -0700256
chaviw68d4dab2020-06-08 15:07:32 -0700257sp<Layer> Layer::getRootLayer() {
258 sp<Layer> parent = getParent();
259 if (parent == nullptr) {
260 return this;
261 }
262 return parent->getRootLayer();
263}
264
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700265void Layer::onRemovedFromCurrentState() {
chaviw68d4dab2020-06-08 15:07:32 -0700266 // Use the root layer since we want to maintain the hierarchy for the entire subtree.
267 auto layersInTree = getRootLayer()->getLayersInTree(LayerVector::StateSet::Current);
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700268 std::sort(layersInTree.begin(), layersInTree.end());
chaviw68d4dab2020-06-08 15:07:32 -0700269
270 traverse(LayerVector::StateSet::Current, [&](Layer* layer) {
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700271 layer->removeFromCurrentState();
272 layer->removeRelativeZ(layersInTree);
chaviw68d4dab2020-06-08 15:07:32 -0700273 });
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700274}
275
chaviw61626f22018-11-15 16:26:27 -0800276void Layer::addToCurrentState() {
277 mRemovedFromCurrentState = false;
278
279 for (const auto& child : mCurrentChildren) {
280 child->addToCurrentState();
281 }
282}
283
Mathias Agopian13127d82013-03-05 17:47:11 -0800284// ---------------------------------------------------------------------------
285// set-up
286// ---------------------------------------------------------------------------
287
chaviw13fdc492017-06-27 12:40:18 -0700288bool Layer::getPremultipledAlpha() const {
289 return mPremultipliedAlpha;
290}
291
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700292sp<IBinder> Layer::getHandle() {
Mathias Agopian13127d82013-03-05 17:47:11 -0800293 Mutex::Autolock _l(mLock);
Robert Carrc0df3122019-04-11 13:18:21 -0700294 if (mGetHandleCalled) {
295 ALOGE("Get handle called twice" );
296 return nullptr;
297 }
298 mGetHandleCalled = true;
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700299 return new Handle(mFlinger, this);
Mathias Agopian13127d82013-03-05 17:47:11 -0800300}
301
302// ---------------------------------------------------------------------------
303// h/w composer set-up
304// ---------------------------------------------------------------------------
305
Mathias Agopianf3e85d42013-05-10 18:01:12 -0700306static Rect reduce(const Rect& win, const Region& exclude) {
307 if (CC_LIKELY(exclude.isEmpty())) {
308 return win;
309 }
310 if (exclude.isRect()) {
311 return win.reduce(exclude.getBounds());
312 }
313 return Region(win).subtract(exclude).getBounds();
314}
315
Dan Stoza80d61162017-12-20 15:57:52 -0800316static FloatRect reduce(const FloatRect& win, const Region& exclude) {
317 if (CC_LIKELY(exclude.isEmpty())) {
318 return win;
319 }
320 // Convert through Rect (by rounding) for lack of FloatRegion
321 return Region(Rect{win}).subtract(exclude).getBounds().toFloatRect();
322}
323
Vishnu Nair4351ad52019-02-11 14:13:02 -0800324Rect Layer::getScreenBounds(bool reduceTransparentRegion) const {
Vishnu Nairf0c28512019-02-08 12:40:28 -0800325 if (!reduceTransparentRegion) {
326 return Rect{mScreenBounds};
327 }
328
329 FloatRect bounds = getBounds();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800330 ui::Transform t = getTransform();
Vishnu Nair60356342018-11-13 13:00:45 -0800331 // Transform to screen space.
332 bounds = t.transform(bounds);
333 return Rect{bounds};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700334}
335
Vishnu Nair4351ad52019-02-11 14:13:02 -0800336FloatRect Layer::getBounds() const {
Alec Mourib416efd2018-09-06 21:01:59 +0000337 const State& s(getDrawingState());
Vishnu Nair4351ad52019-02-11 14:13:02 -0800338 return getBounds(getActiveTransparentRegion(s));
Michael Lentine6c925ed2014-09-26 17:55:01 -0700339}
340
Vishnu Nairf0c28512019-02-08 12:40:28 -0800341FloatRect Layer::getBounds(const Region& activeTransparentRegion) const {
342 // Subtract the transparent region and snap to the bounds.
343 return reduce(mBounds, activeTransparentRegion);
344}
345
Vishnu Nairc652ff82019-03-15 12:48:54 -0700346ui::Transform Layer::getBufferScaleTransform() const {
Vishnu Nair4351ad52019-02-11 14:13:02 -0800347 // If the layer is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g.
348 // it isFixedSize) then there may be additional scaling not accounted
Vishnu Nairc652ff82019-03-15 12:48:54 -0700349 // for in the layer transform.
chaviwd62d3062019-09-04 14:48:02 -0700350 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700351 return {};
Vishnu Nair4351ad52019-02-11 14:13:02 -0800352 }
353
Marissa Wall290ad082019-03-06 13:23:47 -0800354 // If the layer is a buffer state layer, the active width and height
355 // could be infinite. In that case, return the effective transform.
356 const uint32_t activeWidth = getActiveWidth(getDrawingState());
357 const uint32_t activeHeight = getActiveHeight(getDrawingState());
358 if (activeWidth >= UINT32_MAX && activeHeight >= UINT32_MAX) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700359 return {};
Marissa Wall290ad082019-03-06 13:23:47 -0800360 }
361
chaviwd62d3062019-09-04 14:48:02 -0700362 int bufferWidth = getBuffer()->getWidth();
363 int bufferHeight = getBuffer()->getHeight();
Vishnu Nairc652ff82019-03-15 12:48:54 -0700364
chaviw4244e032019-09-04 11:27:49 -0700365 if (getBufferTransform() & NATIVE_WINDOW_TRANSFORM_ROT_90) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700366 std::swap(bufferWidth, bufferHeight);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800367 }
Vishnu Nairc652ff82019-03-15 12:48:54 -0700368
Marissa Wall290ad082019-03-06 13:23:47 -0800369 float sx = activeWidth / static_cast<float>(bufferWidth);
370 float sy = activeHeight / static_cast<float>(bufferHeight);
371
Vishnu Nair4351ad52019-02-11 14:13:02 -0800372 ui::Transform extraParentScaling;
373 extraParentScaling.set(sx, 0, 0, sy);
Vishnu Nairc652ff82019-03-15 12:48:54 -0700374 return extraParentScaling;
375}
376
377ui::Transform Layer::getTransformWithScale(const ui::Transform& bufferScaleTransform) const {
378 // We need to mirror this scaling to child surfaces or we will break the contract where WM can
379 // treat child surfaces as pixels in the parent surface.
chaviwd62d3062019-09-04 14:48:02 -0700380 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700381 return mEffectiveTransform;
382 }
383 return mEffectiveTransform * bufferScaleTransform;
384}
385
386FloatRect Layer::getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const {
387 // We need the pre scaled layer bounds when computing child bounds to make sure the child is
388 // cropped to its parent layer after any buffer transform scaling is applied.
chaviwd62d3062019-09-04 14:48:02 -0700389 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700390 return mBounds;
391 }
392 return bufferScaleTransform.inverse().transform(mBounds);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800393}
394
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700395void Layer::computeBounds(FloatRect parentBounds, ui::Transform parentTransform,
396 float parentShadowRadius) {
Vishnu Nair4351ad52019-02-11 14:13:02 -0800397 const State& s(getDrawingState());
398
399 // Calculate effective layer transform
400 mEffectiveTransform = parentTransform * getActiveTransform(s);
401
402 // Transform parent bounds to layer space
403 parentBounds = getActiveTransform(s).inverse().transform(parentBounds);
404
Vishnu Nairc652ff82019-03-15 12:48:54 -0700405 // Calculate source bounds
Vishnu Nair4351ad52019-02-11 14:13:02 -0800406 mSourceBounds = computeSourceBounds(parentBounds);
407
408 // Calculate bounds by croping diplay frame with layer crop and parent bounds
409 FloatRect bounds = mSourceBounds;
410 const Rect layerCrop = getCrop(s);
411 if (!layerCrop.isEmpty()) {
412 bounds = mSourceBounds.intersect(layerCrop.toFloatRect());
413 }
414 bounds = bounds.intersect(parentBounds);
415
416 mBounds = bounds;
417 mScreenBounds = mEffectiveTransform.transform(mBounds);
Vishnu Nairc652ff82019-03-15 12:48:54 -0700418
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700419 // Use the layer's own shadow radius if set. Otherwise get the radius from
420 // parent.
421 if (s.shadowRadius > 0.f) {
422 mEffectiveShadowRadius = s.shadowRadius;
423 } else {
424 mEffectiveShadowRadius = parentShadowRadius;
425 }
426
427 // Shadow radius is passed down to only one layer so if the layer can draw shadows,
428 // don't pass it to its children.
429 const float childShadowRadius = canDrawShadows() ? 0.f : mEffectiveShadowRadius;
430
Vishnu Nairc652ff82019-03-15 12:48:54 -0700431 // Add any buffer scaling to the layer's children.
432 ui::Transform bufferScaleTransform = getBufferScaleTransform();
Vishnu Nair4351ad52019-02-11 14:13:02 -0800433 for (const sp<Layer>& child : mDrawingChildren) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700434 child->computeBounds(getBoundsPreScaling(bufferScaleTransform),
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700435 getTransformWithScale(bufferScaleTransform), childShadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800436 }
437}
438
Vishnu Nair60356342018-11-13 13:00:45 -0800439Rect Layer::getCroppedBufferSize(const State& s) const {
440 Rect size = getBufferSize(s);
441 Rect crop = getCrop(s);
442 if (!crop.isEmpty() && size.isValid()) {
443 size.intersect(crop, &size);
444 } else if (!crop.isEmpty()) {
445 size = crop;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700446 }
Vishnu Nair60356342018-11-13 13:00:45 -0800447 return size;
Mathias Agopian13127d82013-03-05 17:47:11 -0800448}
449
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700450void Layer::setupRoundedCornersCropCoordinates(Rect win,
451 const FloatRect& roundedCornersCrop) const {
452 // Translate win by the rounded corners rect coordinates, to have all values in
453 // layer coordinate space.
454 win.left -= roundedCornersCrop.left;
455 win.right -= roundedCornersCrop.left;
456 win.top -= roundedCornersCrop.top;
457 win.bottom -= roundedCornersCrop.top;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700458}
459
Lloyd Piquede196652020-01-22 17:29:58 -0800460void Layer::prepareBasicGeometryCompositionState() {
Lloyd Piquec6687342019-03-07 21:34:57 -0800461 const auto& drawingState{getDrawingState()};
462 const uint32_t layerStack = getLayerStack();
463 const auto alpha = static_cast<float>(getAlpha());
464 const bool opaque = isOpaque(drawingState);
465 const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f;
466
467 auto blendMode = Hwc2::IComposerClient::BlendMode::NONE;
468 if (!opaque || alpha != 1.0f) {
469 blendMode = mPremultipliedAlpha ? Hwc2::IComposerClient::BlendMode::PREMULTIPLIED
470 : Hwc2::IComposerClient::BlendMode::COVERAGE;
471 }
472
Lloyd Piquede196652020-01-22 17:29:58 -0800473 auto* compositionState = editCompositionState();
474 compositionState->layerStackId =
Lloyd Piquec6687342019-03-07 21:34:57 -0800475 (layerStack != ~0u) ? std::make_optional(layerStack) : std::nullopt;
Lloyd Piquede196652020-01-22 17:29:58 -0800476 compositionState->internalOnly = getPrimaryDisplayOnly();
477 compositionState->isVisible = isVisible();
478 compositionState->isOpaque = opaque && !usesRoundedCorners && alpha == 1.f;
479 compositionState->shadowRadius = mEffectiveShadowRadius;
Lloyd Piquec6687342019-03-07 21:34:57 -0800480
Lloyd Piquede196652020-01-22 17:29:58 -0800481 compositionState->contentDirty = contentDirty;
Lloyd Piquec6687342019-03-07 21:34:57 -0800482 contentDirty = false;
483
Lloyd Piquede196652020-01-22 17:29:58 -0800484 compositionState->geomLayerBounds = mBounds;
485 compositionState->geomLayerTransform = getTransform();
486 compositionState->geomInverseLayerTransform = compositionState->geomLayerTransform.inverse();
487 compositionState->transparentRegionHint = getActiveTransparentRegion(drawingState);
Lloyd Piquec6687342019-03-07 21:34:57 -0800488
Lloyd Piquede196652020-01-22 17:29:58 -0800489 compositionState->blendMode = static_cast<Hwc2::IComposerClient::BlendMode>(blendMode);
490 compositionState->alpha = alpha;
491 compositionState->backgroundBlurRadius = drawingState.backgroundBlurRadius;
Lucas Dupinc3800b82020-10-02 16:24:48 -0700492 compositionState->blurRegions = drawingState.blurRegions;
John Reckc00c6692021-02-16 11:37:33 -0500493 compositionState->stretchEffect = getStretchEffect();
Lloyd Piquec6687342019-03-07 21:34:57 -0800494}
495
Lloyd Piquede196652020-01-22 17:29:58 -0800496void Layer::prepareGeometryCompositionState() {
Lloyd Piquea83776c2019-01-29 18:42:32 -0800497 const auto& drawingState{getDrawingState()};
Mathias Agopian13127d82013-03-05 17:47:11 -0800498
Lloyd Piquea83776c2019-01-29 18:42:32 -0800499 int type = drawingState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
500 int appId = drawingState.metadata.getInt32(METADATA_OWNER_UID, 0);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700501 sp<Layer> parent = mDrawingParent.promote();
Albert Chaulk2a589632017-05-04 16:59:44 -0400502 if (parent.get()) {
503 auto& parentState = parent->getDrawingState();
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800504 const int parentType = parentState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
505 const int parentAppId = parentState.metadata.getInt32(METADATA_OWNER_UID, 0);
Jiwen 'Steve' Cai736c74e2019-05-28 18:33:22 -0700506 if (parentType > 0 && parentAppId > 0) {
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800507 type = parentType;
508 appId = parentAppId;
rongliucfb187b2018-03-14 12:26:23 -0700509 }
Albert Chaulk2a589632017-05-04 16:59:44 -0400510 }
511
Lloyd Piquede196652020-01-22 17:29:58 -0800512 auto* compositionState = editCompositionState();
David Sodman15094112018-10-11 09:39:37 -0700513
Lloyd Piquede196652020-01-22 17:29:58 -0800514 compositionState->geomBufferSize = getBufferSize(drawingState);
515 compositionState->geomContentCrop = getBufferCrop();
516 compositionState->geomCrop = getCrop(drawingState);
517 compositionState->geomBufferTransform = getBufferTransform();
518 compositionState->geomBufferUsesDisplayInverseTransform = getTransformToDisplayInverse();
519 compositionState->geomUsesSourceCrop = usesSourceCrop();
520 compositionState->isSecure = isSecure();
521
Lloyd Pique8d9f8362020-02-11 19:13:09 -0800522 compositionState->metadata.clear();
523 const auto& supportedMetadata = mFlinger->getHwComposer().getSupportedLayerGenericMetadata();
524 for (const auto& [key, mandatory] : supportedMetadata) {
525 const auto& genericLayerMetadataCompatibilityMap =
526 mFlinger->getGenericLayerMetadataKeyMap();
527 auto compatIter = genericLayerMetadataCompatibilityMap.find(key);
528 if (compatIter == std::end(genericLayerMetadataCompatibilityMap)) {
529 continue;
530 }
531 const uint32_t id = compatIter->second;
532
533 auto it = drawingState.metadata.mMap.find(id);
534 if (it == std::end(drawingState.metadata.mMap)) {
535 continue;
536 }
537
538 compositionState->metadata
539 .emplace(key, compositionengine::GenericLayerMetadataEntry{mandatory, it->second});
540 }
Lloyd Piquea83776c2019-01-29 18:42:32 -0800541}
David Sodmanba340492018-08-05 21:51:33 -0700542
Lloyd Piquede196652020-01-22 17:29:58 -0800543void Layer::preparePerFrameCompositionState() {
Lloyd Pique688abd42019-02-15 15:42:24 -0800544 const auto& drawingState{getDrawingState()};
Lloyd Piquede196652020-01-22 17:29:58 -0800545 auto* compositionState = editCompositionState();
Lloyd Piquef5275482019-01-29 18:42:42 -0800546
Lloyd Piquede196652020-01-22 17:29:58 -0800547 compositionState->forceClientComposition = false;
548
549 compositionState->isColorspaceAgnostic = isColorSpaceAgnostic();
550 compositionState->dataspace = getDataSpace();
551 compositionState->colorTransform = getColorTransform();
552 compositionState->colorTransformIsIdentity = !hasColorTransform();
553 compositionState->surfaceDamage = surfaceDamageRegion;
554 compositionState->hasProtectedContent = isProtected();
Lloyd Pique688abd42019-02-15 15:42:24 -0800555
556 const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f;
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700557
Lloyd Piquede196652020-01-22 17:29:58 -0800558 compositionState->isOpaque =
Lloyd Pique688abd42019-02-15 15:42:24 -0800559 isOpaque(drawingState) && !usesRoundedCorners && getAlpha() == 1.0_hf;
Lloyd Piquef5275482019-01-29 18:42:42 -0800560
561 // Force client composition for special cases known only to the front-end.
John Reckcdb4ed72021-02-04 13:39:33 -0500562 if (isHdrY410() || usesRoundedCorners || drawShadows() || drawingState.blurRegions.size() > 0 ||
John Reckc00c6692021-02-16 11:37:33 -0500563 compositionState->stretchEffect.hasEffect()) {
Lloyd Piquede196652020-01-22 17:29:58 -0800564 compositionState->forceClientComposition = true;
Lloyd Piquef5275482019-01-29 18:42:42 -0800565 }
566}
567
Lloyd Piquede196652020-01-22 17:29:58 -0800568void Layer::prepareCursorCompositionState() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800569 const State& drawingState{getDrawingState()};
Lloyd Piquede196652020-01-22 17:29:58 -0800570 auto* compositionState = editCompositionState();
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800571
572 // Apply the layer's transform, followed by the display's global transform
573 // Here we're guaranteed that the layer's transform preserves rects
574 Rect win = getCroppedBufferSize(drawingState);
575 // Subtract the transparent region and snap to the bounds
576 Rect bounds = reduce(win, getActiveTransparentRegion(drawingState));
577 Rect frame(getTransform().transform(bounds));
578
Lloyd Piquede196652020-01-22 17:29:58 -0800579 compositionState->cursorFrame = frame;
580}
581
582sp<compositionengine::LayerFE> Layer::asLayerFE() const {
583 return const_cast<compositionengine::LayerFE*>(
584 static_cast<const compositionengine::LayerFE*>(this));
585}
586
587sp<compositionengine::LayerFE> Layer::getCompositionEngineLayerFE() const {
588 return nullptr;
589}
590
591compositionengine::LayerFECompositionState* Layer::editCompositionState() {
592 return nullptr;
593}
594
595const compositionengine::LayerFECompositionState* Layer::getCompositionState() const {
596 return nullptr;
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800597}
598
Lloyd Piquef16688f2019-02-19 17:47:57 -0800599bool Layer::onPreComposition(nsecs_t) {
600 return false;
601}
602
Lloyd Piquede196652020-01-22 17:29:58 -0800603void Layer::prepareCompositionState(compositionengine::LayerFE::StateSubset subset) {
Lloyd Piquec6687342019-03-07 21:34:57 -0800604 using StateSubset = compositionengine::LayerFE::StateSubset;
Lloyd Piquef5275482019-01-29 18:42:42 -0800605
Lloyd Piquec6687342019-03-07 21:34:57 -0800606 switch (subset) {
607 case StateSubset::BasicGeometry:
Lloyd Piquede196652020-01-22 17:29:58 -0800608 prepareBasicGeometryCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800609 break;
610
611 case StateSubset::GeometryAndContent:
Lloyd Piquede196652020-01-22 17:29:58 -0800612 prepareBasicGeometryCompositionState();
613 prepareGeometryCompositionState();
614 preparePerFrameCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800615 break;
616
617 case StateSubset::Content:
Lloyd Piquede196652020-01-22 17:29:58 -0800618 preparePerFrameCompositionState();
619 break;
620
621 case StateSubset::Cursor:
622 prepareCursorCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800623 break;
624 }
Lloyd Piquea83776c2019-01-29 18:42:32 -0800625}
Mathias Agopian29a367b2011-07-12 14:51:45 -0700626
Lloyd Piquea83776c2019-01-29 18:42:32 -0800627const char* Layer::getDebugName() const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700628 return mName.c_str();
David Sodman4b7c4bc2017-11-17 12:13:59 -0800629}
630
Mathias Agopian13127d82013-03-05 17:47:11 -0800631// ---------------------------------------------------------------------------
632// drawing...
633// ---------------------------------------------------------------------------
634
Vishnu Nair9b079a22020-01-21 14:36:08 -0800635std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareClientComposition(
Galia Peycheva66eaf4a2020-11-09 13:17:57 +0100636 compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
Lloyd Piquede196652020-01-22 17:29:58 -0800637 if (!getCompositionState()) {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800638 return {};
639 }
Mathias Agopian13127d82013-03-05 17:47:11 -0800640
Vishnu Nair4351ad52019-02-11 14:13:02 -0800641 FloatRect bounds = getBounds();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000642 half alpha = getAlpha();
Vishnu Nair9b079a22020-01-21 14:36:08 -0800643
644 compositionengine::LayerFE::LayerSettings layerSettings;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800645 layerSettings.geometry.boundaries = bounds;
chaviwc6ad8af2020-08-03 11:33:30 -0700646 layerSettings.geometry.positionTransform = getTransform().asMatrix4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000647
648 if (hasColorTransform()) {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800649 layerSettings.colorTransform = getColorTransform();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000650 }
651
652 const auto roundedCornerState = getRoundedCornerState();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800653 layerSettings.geometry.roundedCornersRadius = roundedCornerState.radius;
654 layerSettings.geometry.roundedCornersCrop = roundedCornerState.cropRect;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000655
Lloyd Piquef16688f2019-02-19 17:47:57 -0800656 layerSettings.alpha = alpha;
chaviw4244e032019-09-04 11:27:49 -0700657 layerSettings.sourceDataspace = getDataSpace();
Galia Peycheva66eaf4a2020-11-09 13:17:57 +0100658 if (!targetSettings.disableBlurs) {
659 layerSettings.backgroundBlurRadius = getBackgroundBlurRadius();
660 layerSettings.blurRegions = getBlurRegions();
661 }
John Reckcdb4ed72021-02-04 13:39:33 -0500662 layerSettings.stretchEffect = getDrawingState().stretchEffect;
Ana Krulec6eab17a2020-12-09 15:52:36 -0800663 // Record the name of the layer for debugging further down the stack.
664 layerSettings.name = getName();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800665 return layerSettings;
Mathias Agopian13127d82013-03-05 17:47:11 -0800666}
667
Vishnu Nair9b079a22020-01-21 14:36:08 -0800668std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareShadowClientComposition(
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200669 const LayerFE::LayerSettings& casterLayerSettings, const Rect& layerStackRect,
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800670 ui::Dataspace outputDataspace) {
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200671 renderengine::ShadowSettings shadow = getShadowSettings(layerStackRect);
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800672 if (shadow.length <= 0.f) {
673 return {};
674 }
675
676 const float casterAlpha = casterLayerSettings.alpha;
677 const bool casterIsOpaque = ((casterLayerSettings.source.buffer.buffer != nullptr) &&
678 casterLayerSettings.source.buffer.isOpaque);
679
Vishnu Nair9b079a22020-01-21 14:36:08 -0800680 compositionengine::LayerFE::LayerSettings shadowLayer = casterLayerSettings;
681
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800682 shadowLayer.shadow = shadow;
Vishnu Naira483b4a2019-12-12 15:07:52 -0800683 shadowLayer.geometry.boundaries = mBounds; // ignore transparent region
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800684
685 // If the casting layer is translucent, we need to fill in the shadow underneath the layer.
686 // Otherwise the generated shadow will only be shown around the casting layer.
687 shadowLayer.shadow.casterIsTranslucent = !casterIsOpaque || (casterAlpha < 1.0f);
688 shadowLayer.shadow.ambientColor *= casterAlpha;
689 shadowLayer.shadow.spotColor *= casterAlpha;
690 shadowLayer.sourceDataspace = outputDataspace;
691 shadowLayer.source.buffer.buffer = nullptr;
Vishnu Nair9b079a22020-01-21 14:36:08 -0800692 shadowLayer.source.buffer.fence = nullptr;
693 shadowLayer.frameNumber = 0;
694 shadowLayer.bufferId = 0;
Alec Mouribd17b3b2020-12-17 11:08:30 -0800695 shadowLayer.name = getName();
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800696
697 if (shadowLayer.shadow.ambientColor.a <= 0.f && shadowLayer.shadow.spotColor.a <= 0.f) {
698 return {};
699 }
700
701 float casterCornerRadius = shadowLayer.geometry.roundedCornersRadius;
Vishnu Nair9b079a22020-01-21 14:36:08 -0800702 const FloatRect& cornerRadiusCropRect = shadowLayer.geometry.roundedCornersCrop;
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800703 const FloatRect& casterRect = shadowLayer.geometry.boundaries;
704
705 // crop used to set the corner radius may be larger than the content rect. Adjust the corner
706 // radius accordingly.
707 if (casterCornerRadius > 0.f) {
708 float cropRectOffset = std::max(std::abs(cornerRadiusCropRect.top - casterRect.top),
709 std::abs(cornerRadiusCropRect.left - casterRect.left));
710 if (cropRectOffset > casterCornerRadius) {
711 casterCornerRadius = 0;
712 } else {
713 casterCornerRadius -= cropRectOffset;
714 }
715 shadowLayer.geometry.roundedCornersRadius = casterCornerRadius;
716 }
717
718 return shadowLayer;
719}
720
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800721void Layer::prepareClearClientComposition(LayerFE::LayerSettings& layerSettings,
722 bool blackout) const {
723 layerSettings.source.buffer.buffer = nullptr;
724 layerSettings.source.solidColor = half3(0.0, 0.0, 0.0);
725 layerSettings.disableBlending = true;
Vishnu Nair3b653e72020-02-24 16:40:50 -0800726 layerSettings.bufferId = 0;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800727 layerSettings.frameNumber = 0;
728
729 // If layer is blacked out, force alpha to 1 so that we draw a black color layer.
730 layerSettings.alpha = blackout ? 1.0f : 0.0f;
Alec Mouribd17b3b2020-12-17 11:08:30 -0800731 layerSettings.name = getName();
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800732}
733
734std::vector<compositionengine::LayerFE::LayerSettings> Layer::prepareClientCompositionList(
735 compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
736 std::optional<compositionengine::LayerFE::LayerSettings> layerSettings =
737 prepareClientComposition(targetSettings);
738 // Nothing to render.
739 if (!layerSettings) {
740 return {};
741 }
742
743 // HWC requests to clear this layer.
744 if (targetSettings.clearContent) {
745 prepareClearClientComposition(*layerSettings, false /* blackout */);
746 return {*layerSettings};
747 }
748
749 std::optional<compositionengine::LayerFE::LayerSettings> shadowSettings =
750 prepareShadowClientComposition(*layerSettings, targetSettings.viewport,
751 targetSettings.dataspace);
752 // There are no shadows to render.
753 if (!shadowSettings) {
754 return {*layerSettings};
755 }
756
757 // If the layer casts a shadow but the content casting the shadow is occluded, skip
758 // composing the non-shadow content and only draw the shadows.
759 if (targetSettings.realContentIsVisible) {
760 return {*shadowSettings, *layerSettings};
761 }
762
763 return {*shadowSettings};
764}
765
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700766Hwc2::IComposerClient::Composition Layer::getCompositionType(const DisplayDevice& display) const {
767 const auto outputLayer = findOutputLayerForDisplay(&display);
Alec Mouri6b9e9912020-01-21 10:50:24 -0800768 if (outputLayer == nullptr) {
769 return Hwc2::IComposerClient::Composition::INVALID;
770 }
771 if (outputLayer->getState().hwc) {
772 return (*outputLayer->getState().hwc).hwcCompositionType;
773 } else {
774 return Hwc2::IComposerClient::Composition::CLIENT;
775 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800776}
777
Dan Stozacac35382016-01-27 12:21:06 -0800778bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
779 if (point->getFrameNumber() <= mCurrentFrameNumber) {
780 // Don't bother with a SyncPoint, since we've already latched the
781 // relevant frame
782 return false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700783 }
Robert Carr2e102c92018-10-23 12:11:15 -0700784 if (isRemovedFromCurrentState()) {
785 return false;
786 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700787
Dan Stozacac35382016-01-27 12:21:06 -0800788 Mutex::Autolock lock(mLocalSyncPointMutex);
789 mLocalSyncPoints.push_back(point);
790 return true;
Dan Stoza7dde5992015-05-22 09:51:44 -0700791}
792
Mathias Agopian13127d82013-03-05 17:47:11 -0800793// ----------------------------------------------------------------------------
794// local state
795// ----------------------------------------------------------------------------
796
David Sodman41fdfc92017-11-06 16:09:56 -0800797bool Layer::isSecure() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800798 const State& s(mDrawingState);
Garfield Tande619fa2020-10-02 17:13:53 -0700799 if (s.flags & layer_state_t::eLayerSecure) {
800 return true;
801 }
802
803 const auto p = mDrawingParent.promote();
804 return (p != nullptr) ? p->isSecure() : false;
Dan Stoza23116082015-06-18 14:58:39 -0700805}
806
Mathias Agopian13127d82013-03-05 17:47:11 -0800807// ----------------------------------------------------------------------------
808// transaction
809// ----------------------------------------------------------------------------
Ady Abraham83729882018-12-07 12:26:48 -0800810
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800811void Layer::pushPendingState() {
812 if (!mCurrentState.modified) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700813 return;
814 }
Alec Mourie60041e2019-06-14 18:59:51 -0700815 ATRACE_CALL();
Dan Stoza7dde5992015-05-22 09:51:44 -0700816
Dan Stoza7dde5992015-05-22 09:51:44 -0700817 // If this transaction is waiting on the receipt of a frame, generate a sync
818 // point and send it to the remote layer.
Robert Carr2e102c92018-10-23 12:11:15 -0700819 // We don't allow installing sync points after we are removed from the current state
820 // as we won't be able to signal our end.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800821 if (mCurrentState.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) {
822 sp<Layer> barrierLayer = mCurrentState.barrierLayer_legacy.promote();
Robert Carr0d480722017-01-10 16:42:54 -0800823 if (barrierLayer == nullptr) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700824 ALOGE("[%s] Unable to promote barrier Layer.", getDebugName());
Dan Stoza7dde5992015-05-22 09:51:44 -0700825 // If we can't promote the layer we are intended to wait on,
826 // then it is expired or otherwise invalid. Allow this transaction
827 // to be applied as per normal (no synchronization).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800828 mCurrentState.barrierLayer_legacy = nullptr;
Pablo Ceballos3bddd5b2015-11-19 14:39:14 -0800829 } else {
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800830 auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.barrierFrameNumber, this,
831 barrierLayer);
Robert Carr0d480722017-01-10 16:42:54 -0800832 if (barrierLayer->addSyncPoint(syncPoint)) {
Alec Mourie60041e2019-06-14 18:59:51 -0700833 std::stringstream ss;
Vishnu Nair6b7c5c92020-09-29 17:27:05 -0700834 ss << "Adding sync point " << mCurrentState.barrierFrameNumber;
Alec Mourie60041e2019-06-14 18:59:51 -0700835 ATRACE_NAME(ss.str().c_str());
Dan Stozacac35382016-01-27 12:21:06 -0800836 mRemoteSyncPoints.push_back(std::move(syncPoint));
837 } else {
838 // We already missed the frame we're supposed to synchronize
839 // on, so go ahead and apply the state update
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800840 mCurrentState.barrierLayer_legacy = nullptr;
Dan Stozacac35382016-01-27 12:21:06 -0800841 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700842 }
843
Dan Stoza7dde5992015-05-22 09:51:44 -0700844 // Wake us up to check if the frame has been received
845 setTransactionFlags(eTransactionNeeded);
Dan Stozaf5702ff2016-11-02 16:27:47 -0700846 mFlinger->setTransactionFlags(eTraversalNeeded);
Dan Stoza7dde5992015-05-22 09:51:44 -0700847 }
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000848 if (mCurrentState.bufferlessSurfaceFramesTX.size() >= State::kStateSurfaceFramesThreshold) {
849 // Ideally, the currentState would only contain one SurfaceFrame per transaction (assuming
850 // each Tx uses a different token). We don't expect the current state to hold a huge amount
851 // of SurfaceFrames. However, in the event it happens, this debug statement will leave a
852 // trail that can help in debugging.
853 ALOGW("Bufferless SurfaceFrames size on current state of layer %s is %" PRIu32 "",
854 mName.c_str(), static_cast<uint32_t>(mCurrentState.bufferlessSurfaceFramesTX.size()));
855 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800856 mPendingStates.push_back(mCurrentState);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000857 // Since the current state along with the SurfaceFrames has been pushed into the pendingState,
858 // we no longer need to retain them. If multiple states are pushed and applied together, we have
859 // a merging logic to address the SurfaceFrames at mergeSurfaceFrames().
860 mCurrentState.bufferlessSurfaceFramesTX.clear();
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700861 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700862}
863
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000864void Layer::mergeSurfaceFrames(State& source, State& target) {
865 // No need to merge BufferSurfaceFrame as the target's surfaceFrame, if it exists, will be used
866 // directly. Dropping of source's SurfaceFrame is taken care of at setBuffer().
867 target.bufferlessSurfaceFramesTX.merge(source.bufferlessSurfaceFramesTX);
868 source.bufferlessSurfaceFramesTX.clear();
869}
870
Pablo Ceballos05289c22016-04-14 15:49:55 -0700871void Layer::popPendingState(State* stateToCommit) {
Alec Mourie60041e2019-06-14 18:59:51 -0700872 ATRACE_CALL();
Dan Stoza7dde5992015-05-22 09:51:44 -0700873
Ady Abrahamcfe82582021-02-09 20:10:58 +0000874 mergeSurfaceFrames(*stateToCommit, mPendingStates[0]);
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700875 *stateToCommit = mPendingStates[0];
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800876 mPendingStates.pop_front();
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700877 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700878}
879
Pablo Ceballos05289c22016-04-14 15:49:55 -0700880bool Layer::applyPendingStates(State* stateToCommit) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700881 bool stateUpdateAvailable = false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800882 while (!mPendingStates.empty()) {
883 if (mPendingStates[0].barrierLayer_legacy != nullptr) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700884 if (mRemoteSyncPoints.empty()) {
885 // If we don't have a sync point for this, apply it anyway. It
886 // will be visually wrong, but it should keep us from getting
887 // into too much trouble.
Vishnu Nair9aaf96f2020-11-09 17:53:07 -0800888 ALOGV("[%s] No local sync point found", getDebugName());
Pablo Ceballos05289c22016-04-14 15:49:55 -0700889 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700890 stateUpdateAvailable = true;
891 continue;
892 }
893
Marissa Wallf58c14b2018-07-24 10:50:43 -0700894 if (mRemoteSyncPoints.front()->getFrameNumber() !=
Vishnu Nair6b7c5c92020-09-29 17:27:05 -0700895 mPendingStates[0].barrierFrameNumber) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700896 ALOGE("[%s] Unexpected sync point frame number found", getDebugName());
Dan Stozacac35382016-01-27 12:21:06 -0800897
898 // Signal our end of the sync point and then dispose of it
899 mRemoteSyncPoints.front()->setTransactionApplied();
900 mRemoteSyncPoints.pop_front();
901 continue;
902 }
903
Dan Stoza7dde5992015-05-22 09:51:44 -0700904 if (mRemoteSyncPoints.front()->frameIsAvailable()) {
Alec Mourie60041e2019-06-14 18:59:51 -0700905 ATRACE_NAME("frameIsAvailable");
Dan Stoza7dde5992015-05-22 09:51:44 -0700906 // Apply the state update
Pablo Ceballos05289c22016-04-14 15:49:55 -0700907 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700908 stateUpdateAvailable = true;
909
910 // Signal our end of the sync point and then dispose of it
911 mRemoteSyncPoints.front()->setTransactionApplied();
912 mRemoteSyncPoints.pop_front();
Dan Stoza792e5292016-02-11 11:43:58 -0800913 } else {
Alec Mourie60041e2019-06-14 18:59:51 -0700914 ATRACE_NAME("!frameIsAvailable");
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800915 mRemoteSyncPoints.front()->checkTimeoutAndLog();
Dan Stoza792e5292016-02-11 11:43:58 -0800916 break;
Dan Stoza7dde5992015-05-22 09:51:44 -0700917 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700918 } else {
Pablo Ceballos05289c22016-04-14 15:49:55 -0700919 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700920 stateUpdateAvailable = true;
921 }
922 }
923
Robert Carr4b874132020-05-29 12:02:51 -0700924 // If we still have pending updates, we need to ensure SurfaceFlinger
Valerie Haud50e7412020-06-16 17:58:14 -0700925 // will keep calling doTransaction, and so we force a traversal.
Robert Carr4b874132020-05-29 12:02:51 -0700926 // However, our pending states won't clear until a frame is available,
Valerie Haud50e7412020-06-16 17:58:14 -0700927 // and so there is no need to specifically trigger a wakeup.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800928 if (!mPendingStates.empty()) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700929 setTransactionFlags(eTransactionNeeded);
Valerie Haud50e7412020-06-16 17:58:14 -0700930 mFlinger->setTraversalNeeded();
Dan Stoza7dde5992015-05-22 09:51:44 -0700931 }
932
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800933 mCurrentState.modified = false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700934 return stateUpdateAvailable;
935}
936
Marissa Wall61c58622018-07-18 10:12:20 -0700937uint32_t Layer::doTransactionResize(uint32_t flags, State* stateToCommit) {
Alec Mourib416efd2018-09-06 21:01:59 +0000938 const State& s(getDrawingState());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800939
Marissa Wall61c58622018-07-18 10:12:20 -0700940 const bool sizeChanged = (stateToCommit->requested_legacy.w != s.requested_legacy.w) ||
941 (stateToCommit->requested_legacy.h != s.requested_legacy.h);
Mathias Agopiana138f892010-05-21 17:24:35 -0700942
David Sodmaneb085e02017-10-05 18:49:04 -0700943 if (sizeChanged) {
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700944 // the size changed, we need to ask our client to request a new buffer
Steve Block9d453682011-12-20 16:23:08 +0000945 ALOGD_IF(DEBUG_RESIZE,
David Sodman41fdfc92017-11-06 16:09:56 -0800946 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
947 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
948 " requested={ wh={%4u,%4u} }}\n"
949 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
950 " requested={ wh={%4u,%4u} }}\n",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700951 this, getName().c_str(), getBufferTransform(), getEffectiveScalingMode(),
Marissa Wall61c58622018-07-18 10:12:20 -0700952 stateToCommit->active_legacy.w, stateToCommit->active_legacy.h,
chaviw25714502021-02-11 10:01:08 -0800953 stateToCommit->crop.left, stateToCommit->crop.top, stateToCommit->crop.right,
954 stateToCommit->crop.bottom, stateToCommit->crop.getWidth(),
955 stateToCommit->crop.getHeight(), stateToCommit->requested_legacy.w,
956 stateToCommit->requested_legacy.h, s.active_legacy.w, s.active_legacy.h,
957 s.crop.left, s.crop.top, s.crop.right, s.crop.bottom, s.crop.getWidth(),
958 s.crop.getHeight(), s.requested_legacy.w, s.requested_legacy.h);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800959 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700960
Robert Carre392b552017-09-19 12:16:05 -0700961 // Don't let Layer::doTransaction update the drawing state
962 // if we have a pending resize, unless we are in fixed-size mode.
963 // the drawing state will be updated only once we receive a buffer
964 // with the correct size.
965 //
966 // In particular, we want to make sure the clip (which is part
967 // of the geometry state) is latched together with the size but is
968 // latched immediately when no resizing is involved.
969 //
970 // If a sideband stream is attached, however, we want to skip this
971 // optimization so that transactions aren't missed when a buffer
972 // never arrives
973 //
974 // In the case that we don't have a buffer we ignore other factors
975 // and avoid entering the resizePending state. At a high level the
976 // resizePending state is to avoid applying the state of the new buffer
977 // to the old buffer. However in the state where we don't have an old buffer
978 // there is no such concern but we may still be being used as a parent layer.
Marissa Wall61c58622018-07-18 10:12:20 -0700979 const bool resizePending =
980 ((stateToCommit->requested_legacy.w != stateToCommit->active_legacy.w) ||
981 (stateToCommit->requested_legacy.h != stateToCommit->active_legacy.h)) &&
chaviwd62d3062019-09-04 14:48:02 -0700982 (getBuffer() != nullptr);
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700983 if (!isFixedSize()) {
Lloyd Pique0b785d82018-12-04 17:25:27 -0800984 if (resizePending && mSidebandStream == nullptr) {
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700985 flags |= eDontUpdateGeometryState;
986 }
987 }
988
Robert Carr7bf247e2017-05-18 14:02:49 -0700989 // Here we apply various requested geometry states, depending on our
990 // latching configuration. See Layer.h for a detailed discussion of
991 // how geometry latching is controlled.
992 if (!(flags & eDontUpdateGeometryState)) {
Alec Mourib416efd2018-09-06 21:01:59 +0000993 State& editCurrentState(getCurrentState());
Robert Carr7bf247e2017-05-18 14:02:49 -0700994
Robert Carr7bf247e2017-05-18 14:02:49 -0700995 // There is an awkward asymmetry in the handling of the crop states in the position
996 // states, as can be seen below. Largely this arises from position and transform
997 // being stored in the same data structure while having different latching rules.
998 // b/38182305
999 //
Marissa Wall61c58622018-07-18 10:12:20 -07001000 // Careful that "stateToCommit" and editCurrentState may not begin as equivalent due to
Robert Carr7bf247e2017-05-18 14:02:49 -07001001 // applyPendingStates in the presence of deferred transactions.
chaviw214c89d2019-09-04 16:03:53 -07001002 editCurrentState.active_legacy = editCurrentState.requested_legacy;
1003 stateToCommit->active_legacy = stateToCommit->requested_legacy;
Mathias Agopian13127d82013-03-05 17:47:11 -08001004 }
1005
Marissa Wall61c58622018-07-18 10:12:20 -07001006 return flags;
1007}
1008
1009uint32_t Layer::doTransaction(uint32_t flags) {
1010 ATRACE_CALL();
1011
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001012 if (mChildrenChanged) {
1013 flags |= eVisibleRegion;
1014 mChildrenChanged = false;
chaviw5aedec92018-10-22 10:40:38 -07001015 }
1016
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001017 pushPendingState();
Alec Mourib416efd2018-09-06 21:01:59 +00001018 State c = getCurrentState();
Marissa Wall61c58622018-07-18 10:12:20 -07001019 if (!applyPendingStates(&c)) {
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001020 return flags;
Marissa Wall61c58622018-07-18 10:12:20 -07001021 }
1022
1023 flags = doTransactionResize(flags, &c);
1024
Alec Mourib416efd2018-09-06 21:01:59 +00001025 const State& s(getDrawingState());
Marissa Wall61c58622018-07-18 10:12:20 -07001026
1027 if (getActiveGeometry(c) != getActiveGeometry(s)) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001028 // invalidate and recompute the visible regions if needed
1029 flags |= Layer::eVisibleRegion;
1030 }
1031
Mathias Agopian1eae0ee2013-06-05 16:59:15 -07001032 if (c.sequence != s.sequence) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001033 // invalidate and recompute the visible regions if needed
1034 flags |= eVisibleRegion;
1035 this->contentDirty = true;
1036
1037 // we may use linear filtering, if the matrix scales us
Marin Shalamanov043ba292020-09-10 13:35:20 +02001038 mNeedsFiltering = getActiveTransform(c).needsBilinearFiltering();
Mathias Agopian13127d82013-03-05 17:47:11 -08001039 }
1040
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001041 if (mCurrentState.inputInfoChanged) {
Robert Carr720e5062018-07-30 17:45:14 -07001042 flags |= eInputInfoChanged;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001043 mCurrentState.inputInfoChanged = false;
Robert Carr720e5062018-07-30 17:45:14 -07001044 }
1045
chaviw47dbd692020-10-26 17:50:12 -07001046 // Add the callbacks from the drawing state into the current state. This is so when the current
1047 // state gets copied to drawing, we don't lose the callback handles that are still in drawing.
1048 for (auto& handle : s.callbackHandles) {
1049 c.callbackHandles.push_back(handle);
1050 }
1051
Vishnu Nair1506b182021-02-22 14:35:15 -08001052 // Allow BufferStateLayer to release any unlatched buffers in drawing state.
Alec Mouri2daef3c2021-04-02 16:29:27 -07001053 bufferMayChange(c.buffer->getBuffer());
Vishnu Nair1506b182021-02-22 14:35:15 -08001054
Mathias Agopian13127d82013-03-05 17:47:11 -08001055 // Commit the transaction
Pablo Ceballos05289c22016-04-14 15:49:55 -07001056 commitTransaction(c);
Vishnu Nair8406fd72019-07-30 11:29:31 -07001057 mPendingStatesSnapshot = mPendingStates;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001058 mCurrentState.callbackHandles = {};
Robert Carra1257842020-01-31 13:48:28 -08001059
Mathias Agopian13127d82013-03-05 17:47:11 -08001060 return flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001061}
1062
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001063void Layer::commitTransaction(State& stateToCommit) {
Adithya Srinivasand11eb6b2021-03-09 18:46:28 +00001064 if (auto& bufferSurfaceFrame = mDrawingState.bufferSurfaceFrameTX;
Alec Mouri2daef3c2021-04-02 16:29:27 -07001065 ((mDrawingState.buffer && stateToCommit.buffer &&
1066 mDrawingState.buffer->getBuffer() != stateToCommit.buffer->getBuffer()) ||
1067 (mDrawingState.buffer && !stateToCommit.buffer) ||
1068 (!mDrawingState.buffer && stateToCommit.buffer)) &&
1069 bufferSurfaceFrame != nullptr &&
Adithya Srinivasand11eb6b2021-03-09 18:46:28 +00001070 bufferSurfaceFrame->getPresentState() != PresentState::Presented) {
1071 // If the previous buffer was committed but not latched (refreshPending - happens during
1072 // back to back invalidates), it gets silently dropped here. Mark the corresponding
1073 // SurfaceFrame as dropped to prevent it from getting stuck in the pending classification
1074 // list.
1075 addSurfaceFrameDroppedForBuffer(bufferSurfaceFrame);
1076 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001077 mDrawingState = stateToCommit;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001078
1079 // Set the present state for all bufferlessSurfaceFramesTX to Presented. The
1080 // bufferSurfaceFrameTX will be presented in latchBuffer.
1081 for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {
1082 if (surfaceFrame->getPresentState() != PresentState::Presented) {
1083 // With applyPendingStates, we could end up having presented surfaceframes from previous
1084 // states
1085 surfaceFrame->setPresentState(PresentState::Presented);
1086 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
1087 }
1088 }
1089 // Clear the surfaceFrames from the old state now that it has been copied into DrawingState.
1090 stateToCommit.bufferSurfaceFrameTX.reset();
1091 stateToCommit.bufferlessSurfaceFramesTX.clear();
Mathias Agopiana67932f2011-04-20 14:20:59 -07001092}
1093
Mathias Agopian13127d82013-03-05 17:47:11 -08001094uint32_t Layer::getTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001095 return mTransactionFlags.fetch_and(~flags) & flags;
Mathias Agopian13127d82013-03-05 17:47:11 -08001096}
1097
1098uint32_t Layer::setTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001099 return mTransactionFlags.fetch_or(flags);
Mathias Agopian13127d82013-03-05 17:47:11 -08001100}
1101
chaviw214c89d2019-09-04 16:03:53 -07001102bool Layer::setPosition(float x, float y) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001103 if (mCurrentState.requested_legacy.transform.tx() == x &&
1104 mCurrentState.requested_legacy.transform.ty() == y)
Mathias Agopian13127d82013-03-05 17:47:11 -08001105 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001106 mCurrentState.sequence++;
Robert Carr69663fb2016-03-27 19:59:19 -07001107
1108 // We update the requested and active position simultaneously because
1109 // we want to apply the position portion of the transform matrix immediately,
1110 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001111 mCurrentState.requested_legacy.transform.set(x, y);
chaviw214c89d2019-09-04 16:03:53 -07001112 // Here we directly update the active state
1113 // unlike other setters, because we store it within
1114 // the transform, but use different latching rules.
1115 // b/38182305
1116 mCurrentState.active_legacy.transform.set(x, y);
Robert Carr69663fb2016-03-27 19:59:19 -07001117
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001118 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001119 setTransactionFlags(eTransactionNeeded);
1120 return true;
1121}
Robert Carr82364e32016-05-15 11:27:47 -07001122
Robert Carr1f0a16a2016-10-24 16:27:39 -07001123bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
1124 ssize_t idx = mCurrentChildren.indexOf(childLayer);
1125 if (idx < 0) {
1126 return false;
1127 }
1128 if (childLayer->setLayer(z)) {
1129 mCurrentChildren.removeAt(idx);
1130 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -08001131 return true;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001132 }
Robert Carr503d2bd2017-12-04 15:49:47 -08001133 return false;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001134}
1135
Robert Carr503c7042017-09-27 15:06:08 -07001136bool Layer::setChildRelativeLayer(const sp<Layer>& childLayer,
1137 const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
1138 ssize_t idx = mCurrentChildren.indexOf(childLayer);
1139 if (idx < 0) {
1140 return false;
1141 }
1142 if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) {
1143 mCurrentChildren.removeAt(idx);
1144 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -08001145 return true;
Robert Carr503c7042017-09-27 15:06:08 -07001146 }
Robert Carr503d2bd2017-12-04 15:49:47 -08001147 return false;
Robert Carr503c7042017-09-27 15:06:08 -07001148}
1149
Robert Carrae060832016-11-28 10:51:00 -08001150bool Layer::setLayer(int32_t z) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001151 if (mCurrentState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
1152 mCurrentState.sequence++;
1153 mCurrentState.z = z;
1154 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -07001155
1156 // Discard all relative layering.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001157 if (mCurrentState.zOrderRelativeOf != nullptr) {
1158 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
Robert Carrdb66e622017-04-10 16:55:57 -07001159 if (strongRelative != nullptr) {
1160 strongRelative->removeZOrderRelative(this);
1161 }
chaviw606e5cf2019-03-01 10:12:10 -08001162 setZOrderRelativeOf(nullptr);
Robert Carrdb66e622017-04-10 16:55:57 -07001163 }
Mathias Agopian13127d82013-03-05 17:47:11 -08001164 setTransactionFlags(eTransactionNeeded);
1165 return true;
1166}
Robert Carr1f0a16a2016-10-24 16:27:39 -07001167
Robert Carrdb66e622017-04-10 16:55:57 -07001168void Layer::removeZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001169 mCurrentState.zOrderRelatives.remove(relative);
1170 mCurrentState.sequence++;
1171 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -07001172 setTransactionFlags(eTransactionNeeded);
1173}
1174
1175void Layer::addZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001176 mCurrentState.zOrderRelatives.add(relative);
1177 mCurrentState.modified = true;
1178 mCurrentState.sequence++;
Robert Carrdb66e622017-04-10 16:55:57 -07001179 setTransactionFlags(eTransactionNeeded);
1180}
1181
chaviw606e5cf2019-03-01 10:12:10 -08001182void Layer::setZOrderRelativeOf(const wp<Layer>& relativeOf) {
1183 mCurrentState.zOrderRelativeOf = relativeOf;
1184 mCurrentState.sequence++;
1185 mCurrentState.modified = true;
chaviwbdb8b802019-10-14 09:17:12 -07001186 mCurrentState.isRelativeOf = relativeOf != nullptr;
1187
chaviw606e5cf2019-03-01 10:12:10 -08001188 setTransactionFlags(eTransactionNeeded);
1189}
1190
Robert Carr503d2bd2017-12-04 15:49:47 -08001191bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
Robert Carrdb66e622017-04-10 16:55:57 -07001192 sp<Handle> handle = static_cast<Handle*>(relativeToHandle.get());
1193 if (handle == nullptr) {
1194 return false;
1195 }
1196 sp<Layer> relative = handle->owner.promote();
1197 if (relative == nullptr) {
1198 return false;
1199 }
1200
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001201 if (mCurrentState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) &&
1202 mCurrentState.zOrderRelativeOf == relative) {
Robert Carr503d2bd2017-12-04 15:49:47 -08001203 return false;
1204 }
1205
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001206 mCurrentState.sequence++;
1207 mCurrentState.modified = true;
1208 mCurrentState.z = relativeZ;
Robert Carrdb66e622017-04-10 16:55:57 -07001209
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001210 auto oldZOrderRelativeOf = mCurrentState.zOrderRelativeOf.promote();
chaviw9ab4bd12017-11-03 13:11:00 -07001211 if (oldZOrderRelativeOf != nullptr) {
1212 oldZOrderRelativeOf->removeZOrderRelative(this);
1213 }
chaviw606e5cf2019-03-01 10:12:10 -08001214 setZOrderRelativeOf(relative);
Robert Carrdb66e622017-04-10 16:55:57 -07001215 relative->addZOrderRelative(this);
1216
1217 setTransactionFlags(eTransactionNeeded);
1218
1219 return true;
1220}
1221
Mathias Agopian13127d82013-03-05 17:47:11 -08001222bool Layer::setSize(uint32_t w, uint32_t h) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001223 if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h)
Marissa Wallf58c14b2018-07-24 10:50:43 -07001224 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001225 mCurrentState.requested_legacy.w = w;
1226 mCurrentState.requested_legacy.h = h;
1227 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001228 setTransactionFlags(eTransactionNeeded);
Vishnu Naird01c4432018-08-13 10:38:47 -07001229
1230 // record the new size, from this point on, when the client request
1231 // a buffer, it'll get the new size.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001232 setDefaultBufferSize(mCurrentState.requested_legacy.w, mCurrentState.requested_legacy.h);
Mathias Agopian13127d82013-03-05 17:47:11 -08001233 return true;
1234}
Dan Stoza9e56aa02015-11-02 13:00:03 -08001235bool Layer::setAlpha(float alpha) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001236 if (mCurrentState.color.a == alpha) return false;
1237 mCurrentState.sequence++;
1238 mCurrentState.color.a = alpha;
1239 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001240 setTransactionFlags(eTransactionNeeded);
1241 return true;
1242}
chaviw13fdc492017-06-27 12:40:18 -07001243
Valerie Haudd0b7572019-01-29 14:59:27 -08001244bool Layer::setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace) {
1245 if (!mCurrentState.bgColorLayer && alpha == 0) {
chaviw13fdc492017-06-27 12:40:18 -07001246 return false;
Valerie Hauaa194562019-02-05 16:21:38 -08001247 }
1248 mCurrentState.sequence++;
1249 mCurrentState.modified = true;
1250 setTransactionFlags(eTransactionNeeded);
1251
1252 if (!mCurrentState.bgColorLayer && alpha != 0) {
Valerie Haudd0b7572019-01-29 14:59:27 -08001253 // create background color layer if one does not yet exist
Vishnu Nairfa247b12020-02-11 08:58:26 -08001254 uint32_t flags = ISurfaceComposerClient::eFXSurfaceEffect;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001255 std::string name = mName + "BackgroundColorLayer";
Vishnu Nairfa247b12020-02-11 08:58:26 -08001256 mCurrentState.bgColorLayer = mFlinger->getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001257 LayerCreationArgs(mFlinger.get(), nullptr, std::move(name), 0, 0, flags,
1258 LayerMetadata()));
chaviw13fdc492017-06-27 12:40:18 -07001259
Valerie Haudd0b7572019-01-29 14:59:27 -08001260 // add to child list
1261 addChild(mCurrentState.bgColorLayer);
1262 mFlinger->mLayersAdded = true;
1263 // set up SF to handle added color layer
1264 if (isRemovedFromCurrentState()) {
1265 mCurrentState.bgColorLayer->onRemovedFromCurrentState();
1266 }
1267 mFlinger->setTransactionFlags(eTransactionNeeded);
1268 } else if (mCurrentState.bgColorLayer && alpha == 0) {
1269 mCurrentState.bgColorLayer->reparent(nullptr);
1270 mCurrentState.bgColorLayer = nullptr;
1271 return true;
1272 }
1273
1274 mCurrentState.bgColorLayer->setColor(color);
1275 mCurrentState.bgColorLayer->setLayer(std::numeric_limits<int32_t>::min());
1276 mCurrentState.bgColorLayer->setAlpha(alpha);
1277 mCurrentState.bgColorLayer->setDataspace(dataspace);
1278
chaviw13fdc492017-06-27 12:40:18 -07001279 return true;
1280}
1281
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001282bool Layer::setCornerRadius(float cornerRadius) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001283 if (mCurrentState.cornerRadius == cornerRadius) return false;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001284
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001285 mCurrentState.sequence++;
1286 mCurrentState.cornerRadius = cornerRadius;
1287 mCurrentState.modified = true;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001288 setTransactionFlags(eTransactionNeeded);
1289 return true;
1290}
1291
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001292bool Layer::setBackgroundBlurRadius(int backgroundBlurRadius) {
1293 if (mCurrentState.backgroundBlurRadius == backgroundBlurRadius) return false;
1294
1295 mCurrentState.sequence++;
1296 mCurrentState.backgroundBlurRadius = backgroundBlurRadius;
1297 mCurrentState.modified = true;
1298 setTransactionFlags(eTransactionNeeded);
1299 return true;
1300}
1301
Robert Carrd4ae7f32018-06-07 16:10:57 -07001302bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix,
1303 bool allowNonRectPreservingTransforms) {
Peiyong Linefefaac2018-08-17 12:27:51 -07001304 ui::Transform t;
Robert Carrd4ae7f32018-06-07 16:10:57 -07001305 t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
1306
1307 if (!allowNonRectPreservingTransforms && !t.preserveRects()) {
Hongwei Wang46213ea2020-12-04 17:17:31 -08001308 ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER nor "
1309 "ROTATE_SURFACE_FLINGER ignored");
Robert Carrd4ae7f32018-06-07 16:10:57 -07001310 return false;
1311 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001312 mCurrentState.sequence++;
1313 mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
1314 matrix.dsdy);
1315 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001316 setTransactionFlags(eTransactionNeeded);
1317 return true;
1318}
Marissa Wall61c58622018-07-18 10:12:20 -07001319
Mathias Agopian13127d82013-03-05 17:47:11 -08001320bool Layer::setTransparentRegionHint(const Region& transparent) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001321 mCurrentState.requestedTransparentRegion_legacy = transparent;
1322 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001323 setTransactionFlags(eTransactionNeeded);
1324 return true;
1325}
Ana Krulecc84d09b2019-11-02 23:10:29 +01001326
Lucas Dupinc3800b82020-10-02 16:24:48 -07001327bool Layer::setBlurRegions(const std::vector<BlurRegion>& blurRegions) {
1328 mCurrentState.sequence++;
1329 mCurrentState.blurRegions = blurRegions;
1330 mCurrentState.modified = true;
1331 setTransactionFlags(eTransactionNeeded);
1332 return true;
1333}
1334
Vishnu Nairf6eddb62021-01-27 22:02:11 -08001335bool Layer::setFlags(uint32_t flags, uint32_t mask) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001336 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
1337 if (mCurrentState.flags == newFlags) return false;
1338 mCurrentState.sequence++;
1339 mCurrentState.flags = newFlags;
1340 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001341 setTransactionFlags(eTransactionNeeded);
1342 return true;
1343}
Robert Carr99e27f02016-06-16 15:18:02 -07001344
chaviw25714502021-02-11 10:01:08 -08001345bool Layer::setCrop(const Rect& crop) {
1346 if (mCurrentState.requestedCrop == crop) return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001347 mCurrentState.sequence++;
chaviw25714502021-02-11 10:01:08 -08001348 mCurrentState.requestedCrop = crop;
1349 mCurrentState.crop = crop;
Robert Carr7bf247e2017-05-18 14:02:49 -07001350
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001351 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001352 setTransactionFlags(eTransactionNeeded);
1353 return true;
1354}
Robert Carr8d5227b2017-03-16 15:41:03 -07001355
Evan Roskyef876c92019-01-25 17:46:06 -08001356bool Layer::setMetadata(const LayerMetadata& data) {
1357 if (!mCurrentState.metadata.merge(data, true /* eraseEmpty */)) return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001358 mCurrentState.modified = true;
David Sodman41fdfc92017-11-06 16:09:56 -08001359 setTransactionFlags(eTransactionNeeded);
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001360 return true;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001361}
1362
Mathias Agopian13127d82013-03-05 17:47:11 -08001363bool Layer::setLayerStack(uint32_t layerStack) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001364 if (mCurrentState.layerStack == layerStack) return false;
1365 mCurrentState.sequence++;
1366 mCurrentState.layerStack = layerStack;
1367 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001368 setTransactionFlags(eTransactionNeeded);
1369 return true;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001370}
1371
Peiyong Linc502cb72019-03-01 15:00:23 -08001372bool Layer::setColorSpaceAgnostic(const bool agnostic) {
1373 if (mCurrentState.colorSpaceAgnostic == agnostic) {
1374 return false;
1375 }
1376 mCurrentState.sequence++;
1377 mCurrentState.colorSpaceAgnostic = agnostic;
1378 mCurrentState.modified = true;
1379 setTransactionFlags(eTransactionNeeded);
1380 return true;
1381}
1382
Ana Krulecc84d09b2019-11-02 23:10:29 +01001383bool Layer::setFrameRateSelectionPriority(int32_t priority) {
1384 if (mCurrentState.frameRateSelectionPriority == priority) return false;
1385 mCurrentState.frameRateSelectionPriority = priority;
1386 mCurrentState.sequence++;
1387 mCurrentState.modified = true;
1388 setTransactionFlags(eTransactionNeeded);
1389 return true;
1390}
1391
1392int32_t Layer::getFrameRateSelectionPriority() const {
1393 // Check if layer has priority set.
1394 if (mDrawingState.frameRateSelectionPriority != PRIORITY_UNSET) {
1395 return mDrawingState.frameRateSelectionPriority;
1396 }
1397 // If not, search whether its parents have it set.
1398 sp<Layer> parent = getParent();
1399 if (parent != nullptr) {
1400 return parent->getFrameRateSelectionPriority();
1401 }
1402
1403 return Layer::PRIORITY_UNSET;
1404}
1405
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001406bool Layer::isLayerFocusedBasedOnPriority(int32_t priority) {
1407 return priority == PRIORITY_FOCUSED_WITH_MODE || priority == PRIORITY_FOCUSED_WITHOUT_MODE;
1408};
1409
Robert Carr1f0a16a2016-10-24 16:27:39 -07001410uint32_t Layer::getLayerStack() const {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001411 auto p = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001412 if (p == nullptr) {
1413 return getDrawingState().layerStack;
1414 }
1415 return p->getLayerStack();
1416}
1417
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001418bool Layer::setShadowRadius(float shadowRadius) {
1419 if (mCurrentState.shadowRadius == shadowRadius) {
1420 return false;
1421 }
1422
1423 mCurrentState.sequence++;
1424 mCurrentState.shadowRadius = shadowRadius;
1425 mCurrentState.modified = true;
1426 setTransactionFlags(eTransactionNeeded);
1427 return true;
1428}
1429
Vishnu Nair6213bd92020-05-08 17:42:25 -07001430bool Layer::setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint) {
1431 if (mCurrentState.fixedTransformHint == fixedTransformHint) {
1432 return false;
1433 }
1434
1435 mCurrentState.sequence++;
1436 mCurrentState.fixedTransformHint = fixedTransformHint;
1437 mCurrentState.modified = true;
1438 setTransactionFlags(eTransactionNeeded);
1439 return true;
1440}
1441
John Reckcdb4ed72021-02-04 13:39:33 -05001442bool Layer::setStretchEffect(const StretchEffect& effect) {
1443 StretchEffect temp = effect;
1444 temp.sanitize();
1445 if (mCurrentState.stretchEffect == temp) {
1446 return false;
1447 }
1448 mCurrentState.sequence++;
1449 mCurrentState.stretchEffect = temp;
1450 mCurrentState.modified = true;
1451 setTransactionFlags(eTransactionNeeded);
1452 return true;
1453}
1454
John Reckc00c6692021-02-16 11:37:33 -05001455StretchEffect Layer::getStretchEffect() const {
1456 if (mDrawingState.stretchEffect.hasEffect()) {
1457 return mDrawingState.stretchEffect;
1458 }
1459
1460 sp<Layer> parent = getParent();
1461 if (parent != nullptr) {
1462 auto effect = parent->getStretchEffect();
1463 if (effect.hasEffect()) {
1464 // TODO(b/179047472): Map it? Or do we make the effect be in global space?
1465 return effect;
1466 }
1467 }
1468 return StretchEffect{};
1469}
1470
Ady Abraham60e42ea2020-03-09 19:17:31 -07001471void Layer::updateTreeHasFrameRateVote() {
1472 const auto traverseTree = [&](const LayerVector::Visitor& visitor) {
1473 auto parent = getParent();
1474 while (parent) {
1475 visitor(parent.get());
1476 parent = parent->getParent();
1477 }
1478
1479 traverse(LayerVector::StateSet::Current, visitor);
1480 };
1481
1482 // update parents and children about the vote
Ady Abrahamf467f892020-07-31 16:01:53 -07001483 // First traverse the tree and count how many layers has votes. In addition
1484 // activate the layers in Scheduler's LayerHistory for it to check for changes
Ady Abraham60e42ea2020-03-09 19:17:31 -07001485 int layersWithVote = 0;
Ady Abraham44e9f3b2021-02-16 15:22:58 -08001486 traverseTree([&layersWithVote](Layer* layer) {
Marin Shalamanove8a663d2020-11-24 17:48:00 +01001487 const auto layerVotedWithDefaultCompatibility =
1488 layer->mCurrentState.frameRate.rate.isValid() &&
Ady Abraham414e8b52020-05-21 15:36:04 -07001489 layer->mCurrentState.frameRate.type == FrameRateCompatibility::Default;
1490 const auto layerVotedWithNoVote =
1491 layer->mCurrentState.frameRate.type == FrameRateCompatibility::NoVote;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001492 const auto layerVotedWithExactCompatibility =
1493 layer->mCurrentState.frameRate.type == FrameRateCompatibility::Exact;
Ady Abraham414e8b52020-05-21 15:36:04 -07001494
1495 // We do not count layers that are ExactOrMultiple for the same reason
1496 // we are allowing touch boost for those layers. See
1497 // RefreshRateConfigs::getBestRefreshRate for more details.
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001498 if (layerVotedWithDefaultCompatibility || layerVotedWithNoVote ||
1499 layerVotedWithExactCompatibility) {
Ady Abraham60e42ea2020-03-09 19:17:31 -07001500 layersWithVote++;
1501 }
1502 });
1503
1504 // Now update the other layers
1505 bool transactionNeeded = false;
Ady Abraham44e9f3b2021-02-16 15:22:58 -08001506 traverseTree([layersWithVote, &transactionNeeded, this](Layer* layer) {
1507 const bool treeHasFrameRateVote = layersWithVote > 0;
1508 if (layer->mCurrentState.treeHasFrameRateVote != treeHasFrameRateVote) {
Ady Abraham60e42ea2020-03-09 19:17:31 -07001509 layer->mCurrentState.sequence++;
Ady Abraham44e9f3b2021-02-16 15:22:58 -08001510 layer->mCurrentState.treeHasFrameRateVote = treeHasFrameRateVote;
Ady Abraham60e42ea2020-03-09 19:17:31 -07001511 layer->mCurrentState.modified = true;
1512 layer->setTransactionFlags(eTransactionNeeded);
1513 transactionNeeded = true;
Ady Abraham44e9f3b2021-02-16 15:22:58 -08001514
1515 mFlinger->mScheduler->recordLayerHistory(layer, systemTime(),
1516 LayerHistory::LayerUpdateType::SetFrameRate);
Ady Abraham60e42ea2020-03-09 19:17:31 -07001517 }
1518 });
1519
1520 if (transactionNeeded) {
1521 mFlinger->setTransactionFlags(eTraversalNeeded);
1522 }
1523}
1524
Ady Abraham71c437d2020-01-31 15:56:57 -08001525bool Layer::setFrameRate(FrameRate frameRate) {
Ana Krulec3803b8d2020-02-03 16:35:46 -08001526 if (!mFlinger->useFrameRateApi) {
1527 return false;
1528 }
Steven Thomas3172e202020-01-06 19:25:30 -08001529 if (mCurrentState.frameRate == frameRate) {
1530 return false;
1531 }
1532
1533 mCurrentState.sequence++;
1534 mCurrentState.frameRate = frameRate;
1535 mCurrentState.modified = true;
Ady Abraham60e42ea2020-03-09 19:17:31 -07001536
1537 updateTreeHasFrameRateVote();
1538
Steven Thomas3172e202020-01-06 19:25:30 -08001539 setTransactionFlags(eTransactionNeeded);
1540 return true;
1541}
1542
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001543void Layer::setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info,
1544 nsecs_t postTime) {
1545 mCurrentState.postTime = postTime;
1546
1547 // Check if one of the bufferlessSurfaceFramesTX contains the same vsyncId. This can happen if
1548 // there are two transactions with the same token, the first one without a buffer and the
1549 // second one with a buffer. We promote the bufferlessSurfaceFrame to a bufferSurfaceFrameTX
1550 // in that case.
1551 auto it = mCurrentState.bufferlessSurfaceFramesTX.find(info.vsyncId);
1552 if (it != mCurrentState.bufferlessSurfaceFramesTX.end()) {
1553 // Promote the bufferlessSurfaceFrame to a bufferSurfaceFrameTX
1554 mCurrentState.bufferSurfaceFrameTX = it->second;
1555 mCurrentState.bufferlessSurfaceFramesTX.erase(it);
Adithya Srinivasan785addd2021-03-09 00:38:00 +00001556 mCurrentState.bufferSurfaceFrameTX->promoteToBuffer();
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001557 mCurrentState.bufferSurfaceFrameTX->setActualQueueTime(postTime);
1558 } else {
1559 mCurrentState.bufferSurfaceFrameTX =
1560 createSurfaceFrameForBuffer(info, postTime, mTransactionName);
1561 }
1562}
1563
1564void Layer::setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info,
1565 nsecs_t postTime) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -10001566 mCurrentState.frameTimelineInfo = info;
Ady Abraham22c7b5c2020-09-22 19:33:40 -07001567 mCurrentState.postTime = postTime;
1568 mCurrentState.modified = true;
1569 setTransactionFlags(eTransactionNeeded);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001570
1571 if (const auto& bufferSurfaceFrameTX = mCurrentState.bufferSurfaceFrameTX;
1572 bufferSurfaceFrameTX != nullptr) {
1573 if (bufferSurfaceFrameTX->getToken() == info.vsyncId) {
1574 // BufferSurfaceFrame takes precedence over BufferlessSurfaceFrame. If the same token is
1575 // being used for BufferSurfaceFrame, don't create a new one.
1576 return;
1577 }
1578 }
1579 // For Transactions without a buffer, we create only one SurfaceFrame per vsyncId. If multiple
1580 // transactions use the same vsyncId, we just treat them as one SurfaceFrame (unless they are
1581 // targeting different vsyncs).
1582 auto it = mCurrentState.bufferlessSurfaceFramesTX.find(info.vsyncId);
1583 if (it == mCurrentState.bufferlessSurfaceFramesTX.end()) {
1584 auto surfaceFrame = createSurfaceFrameForTransaction(info, postTime);
1585 mCurrentState.bufferlessSurfaceFramesTX[info.vsyncId] = surfaceFrame;
1586 } else {
1587 if (it->second->getPresentState() == PresentState::Presented) {
1588 // If the SurfaceFrame was already presented, its safe to overwrite it since it must
1589 // have been from previous vsync.
1590 it->second = createSurfaceFrameForTransaction(info, postTime);
1591 }
1592 }
1593}
1594
1595void Layer::addSurfaceFrameDroppedForBuffer(
1596 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame) {
Adithya Srinivasan061c14c2021-02-11 01:19:47 +00001597 surfaceFrame->setDropTime(systemTime());
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001598 surfaceFrame->setPresentState(PresentState::Dropped);
1599 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
1600}
1601
1602void Layer::addSurfaceFramePresentedForBuffer(
1603 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime,
1604 nsecs_t currentLatchTime) {
1605 surfaceFrame->setAcquireFenceTime(acquireFenceTime);
1606 surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);
1607 mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
1608 mLastLatchTime = currentLatchTime;
1609}
1610
1611std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForTransaction(
1612 const FrameTimelineInfo& info, nsecs_t postTime) {
1613 auto surfaceFrame =
Alec Mouriadebf5c2021-01-05 12:57:36 -08001614 mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,
1615 getSequence(), mName,
Adithya Srinivasan785addd2021-03-09 00:38:00 +00001616 mTransactionName,
1617 /*isBuffer*/ false);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001618 // For Transactions, the post time is considered to be both queue and acquire fence time.
1619 surfaceFrame->setActualQueueTime(postTime);
1620 surfaceFrame->setAcquireFenceTime(postTime);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001621 const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
1622 if (fps) {
Alec Mouri819f6302021-02-12 15:37:21 -08001623 surfaceFrame->setRenderRate(*fps);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001624 }
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001625 onSurfaceFrameCreated(surfaceFrame);
1626 return surfaceFrame;
1627}
1628
1629std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForBuffer(
1630 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName) {
1631 auto surfaceFrame =
Alec Mouriadebf5c2021-01-05 12:57:36 -08001632 mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,
Adithya Srinivasan785addd2021-03-09 00:38:00 +00001633 getSequence(), mName, debugName,
1634 /*isBuffer*/ true);
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001635 // For buffers, acquire fence time will set during latch.
1636 surfaceFrame->setActualQueueTime(queueTime);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001637 const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());
1638 if (fps) {
Alec Mouri819f6302021-02-12 15:37:21 -08001639 surfaceFrame->setRenderRate(*fps);
Alec Mouri7d436ec2021-01-27 20:40:50 -08001640 }
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001641 // TODO(b/178542907): Implement onSurfaceFrameCreated for BQLayer as well.
1642 onSurfaceFrameCreated(surfaceFrame);
1643 return surfaceFrame;
Ady Abraham74e17562020-08-24 18:18:19 -07001644}
1645
Ady Abraham60e42ea2020-03-09 19:17:31 -07001646Layer::FrameRate Layer::getFrameRateForLayerTree() const {
1647 const auto frameRate = getDrawingState().frameRate;
Marin Shalamanove8a663d2020-11-24 17:48:00 +01001648 if (frameRate.rate.isValid() || frameRate.type == FrameRateCompatibility::NoVote) {
Ady Abraham60e42ea2020-03-09 19:17:31 -07001649 return frameRate;
1650 }
1651
Ady Abrahamf467f892020-07-31 16:01:53 -07001652 // This layer doesn't have a frame rate. Check if its ancestors have a vote
1653 if (sp<Layer> parent = getParent(); parent) {
1654 if (const auto parentFrameRate = parent->getFrameRateForLayerTree();
1655 parentFrameRate.rate.isValid()) {
1656 return parentFrameRate;
1657 }
1658 }
1659
1660 // This layer and its ancestors don't have a frame rate. If one of successors
1661 // has a vote, return a NoVote for successors to set the vote
Ady Abraham60e42ea2020-03-09 19:17:31 -07001662 if (getDrawingState().treeHasFrameRateVote) {
Marin Shalamanove8a663d2020-11-24 17:48:00 +01001663 return {Fps(0.0f), FrameRateCompatibility::NoVote};
Ady Abraham60e42ea2020-03-09 19:17:31 -07001664 }
1665
1666 return frameRate;
Steven Thomas3172e202020-01-06 19:25:30 -08001667}
1668
Marissa Wallf58c14b2018-07-24 10:50:43 -07001669void Layer::deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
Alec Mourie60041e2019-06-14 18:59:51 -07001670 ATRACE_CALL();
Vishnu Nairedbe6d22020-08-27 11:41:20 -07001671
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001672 mCurrentState.barrierLayer_legacy = barrierLayer;
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07001673 mCurrentState.barrierFrameNumber = frameNumber;
Dan Stoza7dde5992015-05-22 09:51:44 -07001674 // We don't set eTransactionNeeded, because just receiving a deferral
1675 // request without any other state updates shouldn't actually induce a delay
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001676 mCurrentState.modified = true;
1677 pushPendingState();
1678 mCurrentState.barrierLayer_legacy = nullptr;
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07001679 mCurrentState.barrierFrameNumber = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001680 mCurrentState.modified = false;
Robert Carr0d480722017-01-10 16:42:54 -08001681}
1682
Marissa Wallf58c14b2018-07-24 10:50:43 -07001683void Layer::deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
Robert Carr0d480722017-01-10 16:42:54 -08001684 sp<Handle> handle = static_cast<Handle*>(barrierHandle.get());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001685 deferTransactionUntil_legacy(handle->owner.promote(), frameNumber);
Dan Stoza7dde5992015-05-22 09:51:44 -07001686}
1687
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001688// ----------------------------------------------------------------------------
1689// pageflip handling...
1690// ----------------------------------------------------------------------------
1691
Robert Carr1f0a16a2016-10-24 16:27:39 -07001692bool Layer::isHiddenByPolicy() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001693 const State& s(mDrawingState);
Chia-I Wue41dbe62017-06-13 14:10:56 -07001694 const auto& parent = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001695 if (parent != nullptr && parent->isHiddenByPolicy()) {
1696 return true;
1697 }
Robert Carr1c5481e2019-07-01 14:42:27 -07001698 if (usingRelativeZ(LayerVector::StateSet::Drawing)) {
1699 auto zOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote();
1700 if (zOrderRelativeOf != nullptr) {
1701 if (zOrderRelativeOf->isHiddenByPolicy()) {
1702 return true;
1703 }
1704 }
1705 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07001706 return s.flags & layer_state_t::eLayerHidden;
1707}
1708
David Sodman41fdfc92017-11-06 16:09:56 -08001709uint32_t Layer::getEffectiveUsage(uint32_t usage) const {
Mathias Agopiana67932f2011-04-20 14:20:59 -07001710 // TODO: should we do something special if mSecure is set?
1711 if (mProtectedByApp) {
1712 // need a hardware-protected path to external video sink
1713 usage |= GraphicBuffer::USAGE_PROTECTED;
Jamie Gennis54cc83e2010-11-02 11:51:32 -07001714 }
Riley Andrews03414a12014-07-01 14:22:59 -07001715 if (mPotentialCursor) {
1716 usage |= GraphicBuffer::USAGE_CURSOR;
1717 }
Jamie Gennis3599bf22011-08-10 11:48:07 -07001718 usage |= GraphicBuffer::USAGE_HW_COMPOSER;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001719 return usage;
Mathias Agopianb5b7f262010-05-07 15:58:44 -07001720}
1721
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001722void Layer::updateTransformHint(ui::Transform::RotationFlags transformHint) {
1723 if (mFlinger->mDebugDisableTransformHint || transformHint & ui::Transform::ROT_INVALID) {
1724 transformHint = ui::Transform::ROT_0;
Mathias Agopiana4583642011-08-23 18:03:18 -07001725 }
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001726
Vishnu Nair6213bd92020-05-08 17:42:25 -07001727 setTransformHint(transformHint);
Mathias Agopiana4583642011-08-23 18:03:18 -07001728}
1729
Mathias Agopian13127d82013-03-05 17:47:11 -08001730// ----------------------------------------------------------------------------
1731// debugging
1732// ----------------------------------------------------------------------------
1733
Marissa Wall61c58622018-07-18 10:12:20 -07001734// TODO(marissaw): add new layer state info to layer debugging
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001735LayerDebugInfo Layer::getLayerDebugInfo(const DisplayDevice* display) const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001736 using namespace std::string_literals;
1737
Kalle Raitaa099a242017-01-11 11:17:29 -08001738 LayerDebugInfo info;
Alec Mourib416efd2018-09-06 21:01:59 +00001739 const State& ds = getDrawingState();
Kalle Raitaa099a242017-01-11 11:17:29 -08001740 info.mName = getName();
Vishnu Nair43bccf82020-06-05 10:53:37 -07001741 sp<Layer> parent = mDrawingParent.promote();
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001742 info.mParentName = parent ? parent->getName() : "none"s;
chaviw8a01fa42019-08-19 12:39:31 -07001743 info.mType = getType();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001744 info.mTransparentRegion = ds.activeTransparentRegion_legacy;
Lloyd Piquea2468662019-03-07 21:31:06 -08001745
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001746 info.mVisibleRegion = getVisibleRegion(display);
Kalle Raitaa099a242017-01-11 11:17:29 -08001747 info.mSurfaceDamageRegion = surfaceDamageRegion;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001748 info.mLayerStack = getLayerStack();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001749 info.mX = ds.active_legacy.transform.tx();
1750 info.mY = ds.active_legacy.transform.ty();
Kalle Raitaa099a242017-01-11 11:17:29 -08001751 info.mZ = ds.z;
Marissa Wallf58c14b2018-07-24 10:50:43 -07001752 info.mWidth = ds.active_legacy.w;
1753 info.mHeight = ds.active_legacy.h;
chaviw25714502021-02-11 10:01:08 -08001754 info.mCrop = ds.crop;
chaviw13fdc492017-06-27 12:40:18 -07001755 info.mColor = ds.color;
Kalle Raitaa099a242017-01-11 11:17:29 -08001756 info.mFlags = ds.flags;
1757 info.mPixelFormat = getPixelFormat();
chaviw4244e032019-09-04 11:27:49 -07001758 info.mDataSpace = static_cast<android_dataspace>(getDataSpace());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001759 info.mMatrix[0][0] = ds.active_legacy.transform[0][0];
1760 info.mMatrix[0][1] = ds.active_legacy.transform[0][1];
1761 info.mMatrix[1][0] = ds.active_legacy.transform[1][0];
1762 info.mMatrix[1][1] = ds.active_legacy.transform[1][1];
Kalle Raitaa099a242017-01-11 11:17:29 -08001763 {
chaviwd62d3062019-09-04 14:48:02 -07001764 sp<const GraphicBuffer> buffer = getBuffer();
David Sodman5b4cffc2017-11-23 13:20:29 -08001765 if (buffer != 0) {
1766 info.mActiveBufferWidth = buffer->getWidth();
1767 info.mActiveBufferHeight = buffer->getHeight();
1768 info.mActiveBufferStride = buffer->getStride();
1769 info.mActiveBufferFormat = buffer->format;
Kalle Raitaa099a242017-01-11 11:17:29 -08001770 } else {
1771 info.mActiveBufferWidth = 0;
1772 info.mActiveBufferHeight = 0;
1773 info.mActiveBufferStride = 0;
1774 info.mActiveBufferFormat = 0;
1775 }
Mathias Agopian13127d82013-03-05 17:47:11 -08001776 }
Kalle Raitaa099a242017-01-11 11:17:29 -08001777 info.mNumQueuedFrames = getQueuedFrameCount();
1778 info.mRefreshPending = isBufferLatched();
1779 info.mIsOpaque = isOpaque(ds);
1780 info.mContentDirty = contentDirty;
John Reckc00c6692021-02-16 11:37:33 -05001781 info.mStretchEffect = getStretchEffect();
Kalle Raitaa099a242017-01-11 11:17:29 -08001782 return info;
Mathias Agopian13127d82013-03-05 17:47:11 -08001783}
Chia-I Wu83ce7c12017-10-19 15:18:55 -07001784
Yiwei Zhang5434a782018-12-05 18:06:32 -08001785void Layer::miniDumpHeader(std::string& result) {
Marin Shalamanov1876e2e2020-12-04 13:23:59 +01001786 result.append(kDumpTableRowLength, '-');
1787 result.append("\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001788 result.append(" Layer name\n");
1789 result.append(" Z | ");
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001790 result.append(" Window Type | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001791 result.append(" Comp Type | ");
Yichi Chen6ca35192018-05-29 12:20:43 +08001792 result.append(" Transform | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001793 result.append(" Disp Frame (LTRB) | ");
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001794 result.append(" Source Crop (LTRB) | ");
Marin Shalamanov1876e2e2020-12-04 13:23:59 +01001795 result.append(" Frame Rate (Explicit) (Seamlessness) [Focused]\n");
1796 result.append(kDumpTableRowLength, '-');
1797 result.append("\n");
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001798}
1799
1800std::string Layer::frameRateCompatibilityString(Layer::FrameRateCompatibility compatibility) {
1801 switch (compatibility) {
1802 case FrameRateCompatibility::Default:
1803 return "Default";
1804 case FrameRateCompatibility::ExactOrMultiple:
1805 return "ExactOrMultiple";
1806 case FrameRateCompatibility::NoVote:
1807 return "NoVote";
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001808 case FrameRateCompatibility::Exact:
1809 return "Exact";
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001810 }
Dan Stozae22aec72016-08-01 13:20:59 -07001811}
1812
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001813void Layer::miniDump(std::string& result, const DisplayDevice& display) const {
1814 const auto outputLayer = findOutputLayerForDisplay(&display);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001815 if (!outputLayer) {
Dan Stozae22aec72016-08-01 13:20:59 -07001816 return;
1817 }
1818
Yiwei Zhang5434a782018-12-05 18:06:32 -08001819 std::string name;
Dan Stozae22aec72016-08-01 13:20:59 -07001820 if (mName.length() > 77) {
1821 std::string shortened;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001822 shortened.append(mName, 0, 36);
Dan Stozae22aec72016-08-01 13:20:59 -07001823 shortened.append("[...]");
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001824 shortened.append(mName, mName.length() - 36);
1825 name = std::move(shortened);
Dan Stozae22aec72016-08-01 13:20:59 -07001826 } else {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001827 name = mName;
Dan Stozae22aec72016-08-01 13:20:59 -07001828 }
1829
Yiwei Zhang5434a782018-12-05 18:06:32 -08001830 StringAppendF(&result, " %s\n", name.c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07001831
Alec Mourib416efd2018-09-06 21:01:59 +00001832 const State& layerState(getDrawingState());
Lloyd Piquede196652020-01-22 17:29:58 -08001833 const auto& outputLayerState = outputLayer->getState();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001834
Chia-I Wu1e043612018-03-01 09:45:09 -08001835 if (layerState.zOrderRelativeOf != nullptr || mDrawingParent != nullptr) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001836 StringAppendF(&result, " rel %6d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001837 } else {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001838 StringAppendF(&result, " %10d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001839 }
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001840 StringAppendF(&result, " %10d | ", mWindowType);
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001841 StringAppendF(&result, "%10s | ", toString(getCompositionType(display)).c_str());
Lloyd Piquede196652020-01-22 17:29:58 -08001842 StringAppendF(&result, "%10s | ", toString(outputLayerState.bufferTransform).c_str());
1843 const Rect& frame = outputLayerState.displayFrame;
Yiwei Zhang5434a782018-12-05 18:06:32 -08001844 StringAppendF(&result, "%4d %4d %4d %4d | ", frame.left, frame.top, frame.right, frame.bottom);
Lloyd Piquede196652020-01-22 17:29:58 -08001845 const FloatRect& crop = outputLayerState.sourceCrop;
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001846 StringAppendF(&result, "%6.1f %6.1f %6.1f %6.1f | ", crop.left, crop.top, crop.right,
Yiwei Zhang5434a782018-12-05 18:06:32 -08001847 crop.bottom);
Ady Abrahamf467f892020-07-31 16:01:53 -07001848 const auto frameRate = getFrameRateForLayerTree();
1849 if (frameRate.rate.isValid() || frameRate.type != FrameRateCompatibility::Default) {
1850 StringAppendF(&result, "%s %15s %17s", to_string(frameRate.rate).c_str(),
1851 frameRateCompatibilityString(frameRate.type).c_str(),
1852 toString(frameRate.seamlessness).c_str());
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001853 } else {
Marin Shalamanov1876e2e2020-12-04 13:23:59 +01001854 result.append(41, ' ');
Ady Abrahambe23e6a2020-05-04 14:51:16 -07001855 }
Dan Stozae22aec72016-08-01 13:20:59 -07001856
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001857 const auto focused = isLayerFocusedBasedOnPriority(getFrameRateSelectionPriority());
1858 StringAppendF(&result, " [%s]\n", focused ? "*" : " ");
1859
Marin Shalamanov1876e2e2020-12-04 13:23:59 +01001860 result.append(kDumpTableRowLength, '-');
1861 result.append("\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001862}
Dan Stozae22aec72016-08-01 13:20:59 -07001863
Yiwei Zhang5434a782018-12-05 18:06:32 -08001864void Layer::dumpFrameStats(std::string& result) const {
Svetoslavd85084b2014-03-20 10:28:31 -07001865 mFrameTracker.dumpStats(result);
Mathias Agopian13127d82013-03-05 17:47:11 -08001866}
1867
Svetoslavd85084b2014-03-20 10:28:31 -07001868void Layer::clearFrameStats() {
1869 mFrameTracker.clearStats();
Mathias Agopian13127d82013-03-05 17:47:11 -08001870}
1871
Jamie Gennis6547ff42013-07-16 20:12:42 -07001872void Layer::logFrameStats() {
1873 mFrameTracker.logAndResetStats(mName);
1874}
1875
Svetoslavd85084b2014-03-20 10:28:31 -07001876void Layer::getFrameStats(FrameStats* outStats) const {
1877 mFrameTracker.getStats(outStats);
1878}
1879
Yiwei Zhang5434a782018-12-05 18:06:32 -08001880void Layer::dumpFrameEvents(std::string& result) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001881 StringAppendF(&result, "- Layer %s (%s, %p)\n", getName().c_str(), getType(), this);
Brian Andersond6927fb2016-07-23 23:37:30 -07001882 Mutex::Autolock lock(mFrameEventHistoryMutex);
1883 mFrameEventHistory.checkFencesForCompletion();
1884 mFrameEventHistory.dump(result);
1885}
Pablo Ceballos40845df2016-01-25 17:41:15 -08001886
Vishnu Nair0f085c62019-08-30 08:49:12 -07001887void Layer::dumpCallingUidPid(std::string& result) const {
chaviw250bcbb2020-08-05 11:17:54 -07001888 StringAppendF(&result, "Layer %s (%s) callingPid:%d callingUid:%d ownerUid:%d\n",
1889 getName().c_str(), getType(), mCallingPid, mCallingUid, mOwnerUid);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001890}
1891
Brian Anderson5ea5e592016-12-01 16:54:33 -08001892void Layer::onDisconnect() {
1893 Mutex::Autolock lock(mFrameEventHistoryMutex);
1894 mFrameEventHistory.onDisconnect();
Yiwei Zhang1a88c402019-11-18 10:43:58 -08001895 const int32_t layerId = getSequence();
1896 mFlinger->mTimeStats->onDestroy(layerId);
1897 mFlinger->mFrameTracer->onDestroy(layerId);
Brian Anderson5ea5e592016-12-01 16:54:33 -08001898}
1899
Brian Anderson3890c392016-07-25 12:48:08 -07001900void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
David Sodman41fdfc92017-11-06 16:09:56 -08001901 FrameEventHistoryDelta* outDelta) {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001902 if (newTimestamps) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001903 mFlinger->mTimeStats->setPostTime(getSequence(), newTimestamps->frameNumber,
Alec Mouri9a29e672020-09-14 12:39:14 -07001904 getName().c_str(), mOwnerUid, newTimestamps->postedTime);
Yiwei Zhang487340f2019-11-18 17:42:12 -08001905 mFlinger->mTimeStats->setAcquireFence(getSequence(), newTimestamps->frameNumber,
1906 newTimestamps->acquireFence);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001907 }
1908
Brian Andersond6927fb2016-07-23 23:37:30 -07001909 Mutex::Autolock lock(mFrameEventHistoryMutex);
1910 if (newTimestamps) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001911 // If there are any unsignaled fences in the aquire timeline at this
1912 // point, the previously queued frame hasn't been latched yet. Go ahead
1913 // and try to get the signal time here so the syscall is taken out of
1914 // the main thread's critical path.
1915 mAcquireTimeline.updateSignalTimes();
1916 // Push the new fence after updating since it's likely still pending.
Brian Anderson3d4039d2016-09-23 16:31:30 -07001917 mAcquireTimeline.push(newTimestamps->acquireFence);
Brian Andersond6927fb2016-07-23 23:37:30 -07001918 mFrameEventHistory.addQueue(*newTimestamps);
1919 }
1920
Brian Anderson3890c392016-07-25 12:48:08 -07001921 if (outDelta) {
1922 mFrameEventHistory.getAndResetDelta(outDelta);
Brian Andersond6927fb2016-07-23 23:37:30 -07001923 }
Pablo Ceballos40845df2016-01-25 17:41:15 -08001924}
Dan Stozae77c7662016-05-13 11:37:28 -07001925
Chia-I Wu98f1c102017-05-30 14:54:08 -07001926size_t Layer::getChildrenCount() const {
1927 size_t count = 0;
1928 for (const sp<Layer>& child : mCurrentChildren) {
1929 count += 1 + child->getChildrenCount();
1930 }
1931 return count;
1932}
1933
Robert Carr1f0a16a2016-10-24 16:27:39 -07001934void Layer::addChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001935 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001936 setTransactionFlags(eTransactionNeeded);
Robert Carr1323c952019-01-28 18:13:27 -08001937
Robert Carr1f0a16a2016-10-24 16:27:39 -07001938 mCurrentChildren.add(layer);
1939 layer->setParent(this);
Ady Abraham60e42ea2020-03-09 19:17:31 -07001940 updateTreeHasFrameRateVote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001941}
1942
1943ssize_t Layer::removeChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001944 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001945 setTransactionFlags(eTransactionNeeded);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001946
Robert Carr1323c952019-01-28 18:13:27 -08001947 layer->setParent(nullptr);
Ady Abraham60e42ea2020-03-09 19:17:31 -07001948 const auto removeResult = mCurrentChildren.remove(layer);
1949
1950 updateTreeHasFrameRateVote();
1951 layer->updateTreeHasFrameRateVote();
1952
1953 return removeResult;
1954}
1955
Robert Carr15eae092018-03-23 13:43:53 -07001956void Layer::setChildrenDrawingParent(const sp<Layer>& newParent) {
Robert Carr578038f2018-03-09 12:25:24 -08001957 for (const sp<Layer>& child : mDrawingChildren) {
1958 child->mDrawingParent = newParent;
Vishnu Nairc652ff82019-03-15 12:48:54 -07001959 child->computeBounds(newParent->mBounds,
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001960 newParent->getTransformWithScale(newParent->getBufferScaleTransform()),
1961 newParent->mEffectiveShadowRadius);
Robert Carr578038f2018-03-09 12:25:24 -08001962 }
1963}
1964
chaviwf1961f72017-09-18 16:41:07 -07001965bool Layer::reparent(const sp<IBinder>& newParentHandle) {
Robert Carr54cf5b12019-01-25 14:02:28 -08001966 sp<Layer> newParent;
1967 if (newParentHandle != nullptr) {
1968 auto handle = static_cast<Handle*>(newParentHandle.get());
1969 newParent = handle->owner.promote();
1970 if (newParent == nullptr) {
1971 ALOGE("Unable to promote Layer handle");
1972 return false;
1973 }
1974 if (newParent == this) {
1975 ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str());
1976 return false;
1977 }
1978 }
1979
chaviwf1961f72017-09-18 16:41:07 -07001980 sp<Layer> parent = getParent();
1981 if (parent != nullptr) {
1982 parent->removeChild(this);
chaviw06178942017-07-27 10:25:59 -07001983 }
1984
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001985 if (newParentHandle != nullptr) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001986 newParent->addChild(this);
1987 if (!newParent->isRemovedFromCurrentState()) {
1988 addToCurrentState();
1989 } else {
1990 onRemovedFromCurrentState();
1991 }
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001992 } else {
1993 onRemovedFromCurrentState();
chaviw61626f22018-11-15 16:26:27 -08001994 }
1995
chaviw06178942017-07-27 10:25:59 -07001996 return true;
1997}
1998
Peiyong Lind3788632018-09-18 16:01:31 -07001999bool Layer::setColorTransform(const mat4& matrix) {
Peiyong Lin747321c2018-10-01 10:03:11 -07002000 static const mat4 identityMatrix = mat4();
2001
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002002 if (mCurrentState.colorTransform == matrix) {
Peiyong Lind3788632018-09-18 16:01:31 -07002003 return false;
2004 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002005 ++mCurrentState.sequence;
2006 mCurrentState.colorTransform = matrix;
2007 mCurrentState.hasColorTransform = matrix != identityMatrix;
2008 mCurrentState.modified = true;
Peiyong Lind3788632018-09-18 16:01:31 -07002009 setTransactionFlags(eTransactionNeeded);
2010 return true;
2011}
2012
chaviwf66724d2018-11-28 16:35:21 -08002013mat4 Layer::getColorTransform() const {
2014 mat4 colorTransform = mat4(getDrawingState().colorTransform);
2015 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
2016 colorTransform = parent->getColorTransform() * colorTransform;
2017 }
2018 return colorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07002019}
2020
2021bool Layer::hasColorTransform() const {
chaviwf66724d2018-11-28 16:35:21 -08002022 bool hasColorTransform = getDrawingState().hasColorTransform;
2023 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
2024 hasColorTransform = hasColorTransform || parent->hasColorTransform();
2025 }
2026 return hasColorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07002027}
2028
Chia-I Wu11481472018-05-04 10:43:19 -07002029bool Layer::isLegacyDataSpace() const {
2030 // return true when no higher bits are set
chaviw4244e032019-09-04 11:27:49 -07002031 return !(getDataSpace() &
2032 (ui::Dataspace::STANDARD_MASK | ui::Dataspace::TRANSFER_MASK |
2033 ui::Dataspace::RANGE_MASK));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08002034}
2035
Robert Carr1f0a16a2016-10-24 16:27:39 -07002036void Layer::setParent(const sp<Layer>& layer) {
Chia-I Wue41dbe62017-06-13 14:10:56 -07002037 mCurrentParent = layer;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002038}
2039
chaviw301b1d82019-11-06 13:15:09 -08002040int32_t Layer::getZ(LayerVector::StateSet stateSet) const {
2041 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2042 const State& state = useDrawing ? mDrawingState : mCurrentState;
2043 return state.z;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002044}
2045
Robert Carr1c5481e2019-07-01 14:42:27 -07002046bool Layer::usingRelativeZ(LayerVector::StateSet stateSet) const {
Robert Carr29abff82017-12-04 13:51:20 -08002047 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002048 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviwe5ac40f2019-09-24 16:36:55 -07002049 return state.isRelativeOf;
Robert Carr29abff82017-12-04 13:51:20 -08002050}
2051
David Sodman41fdfc92017-11-06 16:09:56 -08002052__attribute__((no_sanitize("unsigned-integer-overflow"))) LayerVector Layer::makeTraversalList(
Robert Carr29abff82017-12-04 13:51:20 -08002053 LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers) {
Dan Stoza412903f2017-04-27 13:42:17 -07002054 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
2055 "makeTraversalList received invalid stateSet");
2056 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2057 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002058 const State& state = useDrawing ? mDrawingState : mCurrentState;
Dan Stoza412903f2017-04-27 13:42:17 -07002059
Robert Carr29abff82017-12-04 13:51:20 -08002060 if (state.zOrderRelatives.size() == 0) {
2061 *outSkipRelativeZUsers = true;
2062 return children;
2063 }
2064
chaviwfd462612018-05-31 16:11:27 -07002065 LayerVector traverse(stateSet);
Dan Stoza412903f2017-04-27 13:42:17 -07002066 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
Robert Carrdb66e622017-04-10 16:55:57 -07002067 sp<Layer> strongRelative = weakRelative.promote();
2068 if (strongRelative != nullptr) {
2069 traverse.add(strongRelative);
Robert Carrdb66e622017-04-10 16:55:57 -07002070 }
2071 }
2072
Dan Stoza412903f2017-04-27 13:42:17 -07002073 for (const sp<Layer>& child : children) {
chaviwe5ac40f2019-09-24 16:36:55 -07002074 if (child->usingRelativeZ(stateSet)) {
Robert Carr503c7042017-09-27 15:06:08 -07002075 continue;
2076 }
Robert Carrdb66e622017-04-10 16:55:57 -07002077 traverse.add(child);
2078 }
2079
2080 return traverse;
2081}
2082
Robert Carr1f0a16a2016-10-24 16:27:39 -07002083/**
Robert Carrdb66e622017-04-10 16:55:57 -07002084 * Negatively signed relatives are before 'this' in Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07002085 */
Dan Stoza412903f2017-04-27 13:42:17 -07002086void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08002087 // In the case we have other layers who are using a relative Z to us, makeTraversalList will
2088 // produce a new list for traversing, including our relatives, and not including our children
2089 // who are relatives of another surface. In the case that there are no relative Z,
2090 // makeTraversalList returns our children directly to avoid significant overhead.
2091 // However in this case we need to take the responsibility for filtering children which
2092 // are relatives of another surface here.
2093 bool skipRelativeZUsers = false;
2094 const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07002095
Robert Carr1f0a16a2016-10-24 16:27:39 -07002096 size_t i = 0;
Robert Carrdb66e622017-04-10 16:55:57 -07002097 for (; i < list.size(); i++) {
2098 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08002099 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
2100 continue;
2101 }
2102
chaviw301b1d82019-11-06 13:15:09 -08002103 if (relative->getZ(stateSet) >= 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002104 break;
Robert Carrdb66e622017-04-10 16:55:57 -07002105 }
Dan Stoza412903f2017-04-27 13:42:17 -07002106 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002107 }
Robert Carr29abff82017-12-04 13:51:20 -08002108
Dan Stoza412903f2017-04-27 13:42:17 -07002109 visitor(this);
Robert Carrdb66e622017-04-10 16:55:57 -07002110 for (; i < list.size(); i++) {
2111 const auto& relative = list[i];
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002112
Robert Carr29abff82017-12-04 13:51:20 -08002113 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
2114 continue;
2115 }
Dan Stoza412903f2017-04-27 13:42:17 -07002116 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002117 }
2118}
2119
2120/**
Robert Carrdb66e622017-04-10 16:55:57 -07002121 * Positively signed relatives are before 'this' in reverse Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07002122 */
Dan Stoza412903f2017-04-27 13:42:17 -07002123void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet,
2124 const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08002125 // See traverseInZOrder for documentation.
2126 bool skipRelativeZUsers = false;
2127 LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07002128
Robert Carr1f0a16a2016-10-24 16:27:39 -07002129 int32_t i = 0;
Joel Galensonbf324992017-11-06 11:04:12 -08002130 for (i = int32_t(list.size()) - 1; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07002131 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08002132
2133 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
2134 continue;
2135 }
2136
chaviw301b1d82019-11-06 13:15:09 -08002137 if (relative->getZ(stateSet) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07002138 break;
2139 }
Dan Stoza412903f2017-04-27 13:42:17 -07002140 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002141 }
Dan Stoza412903f2017-04-27 13:42:17 -07002142 visitor(this);
David Sodman41fdfc92017-11-06 16:09:56 -08002143 for (; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07002144 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08002145
2146 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
2147 continue;
2148 }
2149
Dan Stoza412903f2017-04-27 13:42:17 -07002150 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07002151 }
2152}
2153
Edgar Arriaga844fa672020-01-16 14:21:42 -08002154void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) {
2155 visitor(this);
2156 const LayerVector& children =
2157 state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren;
2158 for (const sp<Layer>& child : children) {
2159 child->traverse(state, visitor);
2160 }
2161}
2162
chaviw4b129c22018-04-09 16:19:43 -07002163LayerVector Layer::makeChildrenTraversalList(LayerVector::StateSet stateSet,
2164 const std::vector<Layer*>& layersInTree) {
2165 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
2166 "makeTraversalList received invalid stateSet");
chaviwa76b2712017-09-20 12:02:26 -07002167 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2168 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002169 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07002170
chaviwfd462612018-05-31 16:11:27 -07002171 LayerVector traverse(stateSet);
chaviw4b129c22018-04-09 16:19:43 -07002172 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
2173 sp<Layer> strongRelative = weakRelative.promote();
2174 // Only add relative layers that are also descendents of the top most parent of the tree.
2175 // If a relative layer is not a descendent, then it should be ignored.
2176 if (std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
2177 traverse.add(strongRelative);
2178 }
2179 }
2180
2181 for (const sp<Layer>& child : children) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002182 const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07002183 // If a layer has a relativeOf layer, only ignore if the layer it's relative to is a
2184 // descendent of the top most parent of the tree. If it's not a descendent, then just add
2185 // the child here since it won't be added later as a relative.
2186 if (std::binary_search(layersInTree.begin(), layersInTree.end(),
2187 childState.zOrderRelativeOf.promote().get())) {
2188 continue;
2189 }
2190 traverse.add(child);
2191 }
2192
2193 return traverse;
2194}
2195
2196void Layer::traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
2197 LayerVector::StateSet stateSet,
2198 const LayerVector::Visitor& visitor) {
2199 const LayerVector list = makeChildrenTraversalList(stateSet, layersInTree);
chaviwa76b2712017-09-20 12:02:26 -07002200
2201 size_t i = 0;
chaviw4b129c22018-04-09 16:19:43 -07002202 for (; i < list.size(); i++) {
2203 const auto& relative = list[i];
chaviw301b1d82019-11-06 13:15:09 -08002204 if (relative->getZ(stateSet) >= 0) {
chaviwa76b2712017-09-20 12:02:26 -07002205 break;
2206 }
chaviw4b129c22018-04-09 16:19:43 -07002207 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07002208 }
chaviw4b129c22018-04-09 16:19:43 -07002209
chaviwa76b2712017-09-20 12:02:26 -07002210 visitor(this);
chaviw4b129c22018-04-09 16:19:43 -07002211 for (; i < list.size(); i++) {
2212 const auto& relative = list[i];
2213 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07002214 }
2215}
2216
chaviw4b129c22018-04-09 16:19:43 -07002217std::vector<Layer*> Layer::getLayersInTree(LayerVector::StateSet stateSet) {
2218 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2219 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
2220
2221 std::vector<Layer*> layersInTree = {this};
2222 for (size_t i = 0; i < children.size(); i++) {
2223 const auto& child = children[i];
2224 std::vector<Layer*> childLayers = child->getLayersInTree(stateSet);
2225 layersInTree.insert(layersInTree.end(), childLayers.cbegin(), childLayers.cend());
2226 }
2227
2228 return layersInTree;
2229}
2230
2231void Layer::traverseChildrenInZOrder(LayerVector::StateSet stateSet,
2232 const LayerVector::Visitor& visitor) {
2233 std::vector<Layer*> layersInTree = getLayersInTree(stateSet);
2234 std::sort(layersInTree.begin(), layersInTree.end());
2235 traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
2236}
2237
Peiyong Linefefaac2018-08-17 12:27:51 -07002238ui::Transform Layer::getTransform() const {
Vishnu Nairf0c28512019-02-08 12:40:28 -08002239 return mEffectiveTransform;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002240}
2241
chaviw13fdc492017-06-27 12:40:18 -07002242half Layer::getAlpha() const {
Ady Abraham83729882018-12-07 12:26:48 -08002243 const auto& p = mDrawingParent.promote();
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002244
chaviw13fdc492017-06-27 12:40:18 -07002245 half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf;
2246 return parentAlpha * getDrawingState().color.a;
Robert Carr6452f122017-03-21 10:41:29 -07002247}
Robert Carr6452f122017-03-21 10:41:29 -07002248
Vishnu Nair6213bd92020-05-08 17:42:25 -07002249ui::Transform::RotationFlags Layer::getFixedTransformHint() const {
2250 ui::Transform::RotationFlags fixedTransformHint = mCurrentState.fixedTransformHint;
2251 if (fixedTransformHint != ui::Transform::ROT_INVALID) {
2252 return fixedTransformHint;
2253 }
2254 const auto& p = mCurrentParent.promote();
2255 if (!p) return fixedTransformHint;
2256 return p->getFixedTransformHint();
2257}
2258
chaviw13fdc492017-06-27 12:40:18 -07002259half4 Layer::getColor() const {
2260 const half4 color(getDrawingState().color);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002261 return half4(color.r, color.g, color.b, getAlpha());
Robert Carr6452f122017-03-21 10:41:29 -07002262}
Robert Carr6452f122017-03-21 10:41:29 -07002263
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08002264int32_t Layer::getBackgroundBlurRadius() const {
Galia Peychevada7de0e2020-12-03 17:24:35 +01002265 const auto& p = mDrawingParent.promote();
2266
2267 half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf;
2268 return parentAlpha * getDrawingState().backgroundBlurRadius;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08002269}
2270
Galia Peychevae0acf382021-04-12 21:22:34 +02002271const std::vector<BlurRegion> Layer::getBlurRegions() const {
2272 auto regionsCopy(getDrawingState().blurRegions);
2273 int layerAlpha = getAlpha();
2274 for (auto& region : regionsCopy) {
2275 region.alpha = region.alpha * layerAlpha;
2276 }
2277 return regionsCopy;
Lucas Dupinc3800b82020-10-02 16:24:48 -07002278}
2279
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002280Layer::RoundedCornerState Layer::getRoundedCornerState() const {
2281 const auto& p = mDrawingParent.promote();
2282 if (p != nullptr) {
Peiyong Lin27016a92019-03-29 17:36:08 +00002283 RoundedCornerState parentState = p->getRoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002284 if (parentState.radius > 0) {
2285 ui::Transform t = getActiveTransform(getDrawingState());
2286 t = t.inverse();
2287 parentState.cropRect = t.transform(parentState.cropRect);
2288 // The rounded corners shader only accepts 1 corner radius for performance reasons,
2289 // but a transform matrix can define horizontal and vertical scales.
2290 // Let's take the average between both of them and pass into the shader, practically we
2291 // never do this type of transformation on windows anyway.
Lucas Dupineab7ea02020-06-03 17:27:28 -07002292 auto scaleX = sqrtf(t[0][0] * t[0][0] + t[0][1] * t[0][1]);
2293 auto scaleY = sqrtf(t[1][0] * t[1][0] + t[1][1] * t[1][1]);
2294 parentState.radius *= (scaleX + scaleY) / 2.0f;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002295 return parentState;
2296 }
2297 }
2298 const float radius = getDrawingState().cornerRadius;
Chavi Weingartena5aedbd2021-04-09 13:37:33 +00002299 return radius > 0 && getCroppedBufferSize(getDrawingState()).isValid()
2300 ? RoundedCornerState(getCroppedBufferSize(getDrawingState()).toFloatRect(), radius)
Peiyong Linb9ff23e2019-04-08 11:04:59 -07002301 : RoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002302}
2303
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002304renderengine::ShadowSettings Layer::getShadowSettings(const Rect& layerStackRect) const {
Vishnu Nair08f6eae2019-11-26 14:01:39 -08002305 renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings;
2306
2307 // Shift the spot light x-position to the middle of the display and then
2308 // offset it by casting layer's screen pos.
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02002309 state.lightPos.x = (layerStackRect.width() / 2.f) - mScreenBounds.left;
Vishnu Nair08f6eae2019-11-26 14:01:39 -08002310 state.lightPos.y -= mScreenBounds.top;
2311
2312 state.length = mEffectiveShadowRadius;
2313 return state;
2314}
2315
Robert Carr1f0a16a2016-10-24 16:27:39 -07002316void Layer::commitChildList() {
2317 for (size_t i = 0; i < mCurrentChildren.size(); i++) {
2318 const auto& child = mCurrentChildren[i];
2319 child->commitChildList();
2320 }
2321 mDrawingChildren = mCurrentChildren;
Chia-I Wue41dbe62017-06-13 14:10:56 -07002322 mDrawingParent = mCurrentParent;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002323}
2324
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002325static wp<Layer> extractLayerFromBinder(const wp<IBinder>& weakBinderHandle) {
2326 if (weakBinderHandle == nullptr) {
2327 return nullptr;
2328 }
2329 sp<IBinder> binderHandle = weakBinderHandle.promote();
2330 if (binderHandle == nullptr) {
2331 return nullptr;
2332 }
2333 sp<Layer::Handle> handle = static_cast<Layer::Handle*>(binderHandle.get());
2334 if (handle == nullptr) {
2335 return nullptr;
2336 }
2337 return handle->owner;
2338}
2339
Robert Carr720e5062018-07-30 17:45:14 -07002340void Layer::setInputInfo(const InputWindowInfo& info) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002341 mCurrentState.inputInfo = info;
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002342 mCurrentState.touchableRegionCrop = extractLayerFromBinder(info.touchableRegionCropHandle);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002343 mCurrentState.modified = true;
2344 mCurrentState.inputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002345 setTransactionFlags(eTransactionNeeded);
2346}
2347
Alec Mouri6b9e9912020-01-21 10:50:24 -08002348LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags,
chaviw4c34a092020-07-08 11:30:06 -07002349 const DisplayDevice* display) {
chaviw08f3cb22020-01-13 13:17:21 -08002350 LayerProto* layerProto = layersProto.add_layers();
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002351 writeToProtoDrawingState(layerProto, traceFlags, display);
chaviw08f3cb22020-01-13 13:17:21 -08002352 writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);
2353
Vishnu Nair60db8c02020-04-02 11:55:16 -07002354 if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) {
2355 // Only populate for the primary display.
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002356 if (display) {
2357 const Hwc2::IComposerClient::Composition compositionType = getCompositionType(*display);
Vishnu Nair60db8c02020-04-02 11:55:16 -07002358 layerProto->set_hwc_composition_type(static_cast<HwcCompositionType>(compositionType));
2359 }
Alec Mouri6b9e9912020-01-21 10:50:24 -08002360 }
2361
chaviw08f3cb22020-01-13 13:17:21 -08002362 for (const sp<Layer>& layer : mDrawingChildren) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002363 layer->writeToProto(layersProto, traceFlags, display);
chaviw08f3cb22020-01-13 13:17:21 -08002364 }
chaviw6d89e2d2020-01-14 14:42:01 -08002365
2366 return layerProto;
chaviw08f3cb22020-01-13 13:17:21 -08002367}
2368
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002369void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags,
chaviw4c34a092020-07-08 11:30:06 -07002370 const DisplayDevice* display) {
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07002371 const ui::Transform transform = getTransform();
Vishnu Nair8406fd72019-07-30 11:29:31 -07002372
2373 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
2374 for (const auto& pendingState : mPendingStatesSnapshot) {
2375 auto barrierLayer = pendingState.barrierLayer_legacy.promote();
2376 if (barrierLayer != nullptr) {
2377 BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();
2378 barrierLayerProto->set_id(barrierLayer->sequence);
Vishnu Nair6b7c5c92020-09-29 17:27:05 -07002379 barrierLayerProto->set_frame_number(pendingState.barrierFrameNumber);
Vishnu Nair8406fd72019-07-30 11:29:31 -07002380 }
2381 }
2382
chaviwd62d3062019-09-04 14:48:02 -07002383 auto buffer = getBuffer();
Vishnu Nair8406fd72019-07-30 11:29:31 -07002384 if (buffer != nullptr) {
2385 LayerProtoHelper::writeToProto(buffer,
2386 [&]() { return layerInfo->mutable_active_buffer(); });
chaviw4244e032019-09-04 11:27:49 -07002387 LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()),
Vishnu Nair8406fd72019-07-30 11:29:31 -07002388 layerInfo->mutable_buffer_transform());
2389 }
2390 layerInfo->set_invalidate(contentDirty);
2391 layerInfo->set_is_protected(isProtected());
chaviw4244e032019-09-04 11:27:49 -07002392 layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(getDataSpace())));
Vishnu Nair8406fd72019-07-30 11:29:31 -07002393 layerInfo->set_queued_frames(getQueuedFrameCount());
2394 layerInfo->set_refresh_pending(isBufferLatched());
2395 layerInfo->set_curr_frame(mCurrentFrameNumber);
2396 layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());
2397
2398 layerInfo->set_corner_radius(getRoundedCornerState().radius);
Ana Krulece766cc82020-04-27 13:49:13 -07002399 layerInfo->set_background_blur_radius(getBackgroundBlurRadius());
Vishnu Nair8406fd72019-07-30 11:29:31 -07002400 LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());
2401 LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),
2402 [&]() { return layerInfo->mutable_position(); });
2403 LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
Vishnu Nair60db8c02020-04-02 11:55:16 -07002404 if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002405 LayerProtoHelper::writeToProto(getVisibleRegion(display),
Vishnu Nair60db8c02020-04-02 11:55:16 -07002406 [&]() { return layerInfo->mutable_visible_region(); });
2407 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07002408 LayerProtoHelper::writeToProto(surfaceDamageRegion,
2409 [&]() { return layerInfo->mutable_damage_region(); });
chaviwddeae262020-01-06 10:31:23 -08002410
2411 if (hasColorTransform()) {
2412 LayerProtoHelper::writeToProto(getColorTransform(),
2413 layerInfo->mutable_color_transform());
2414 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07002415 }
2416
Vishnu Nair60db8c02020-04-02 11:55:16 -07002417 LayerProtoHelper::writeToProto(mSourceBounds,
2418 [&]() { return layerInfo->mutable_source_bounds(); });
2419 LayerProtoHelper::writeToProto(mScreenBounds,
2420 [&]() { return layerInfo->mutable_screen_bounds(); });
2421 LayerProtoHelper::writeToProto(getRoundedCornerState().cropRect,
2422 [&]() { return layerInfo->mutable_corner_radius_crop(); });
2423 layerInfo->set_shadow_radius(mEffectiveShadowRadius);
Vishnu Nair8406fd72019-07-30 11:29:31 -07002424}
2425
2426void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,
chaviw4c34a092020-07-08 11:30:06 -07002427 uint32_t traceFlags) {
chaviw1d044282017-09-27 12:19:28 -07002428 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2429 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002430 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw1d044282017-09-27 12:19:28 -07002431
chaviw766c9c52021-02-10 17:36:47 -08002432 ui::Transform requestedTransform = state.transform;
chaviw1d044282017-09-27 12:19:28 -07002433
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002434 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
2435 layerInfo->set_id(sequence);
2436 layerInfo->set_name(getName().c_str());
chaviw8a01fa42019-08-19 12:39:31 -07002437 layerInfo->set_type(getType());
chaviw1d044282017-09-27 12:19:28 -07002438
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002439 for (const auto& child : children) {
2440 layerInfo->add_children(child->sequence);
chaviw1d044282017-09-27 12:19:28 -07002441 }
chaviw1d044282017-09-27 12:19:28 -07002442
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002443 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
2444 sp<Layer> strongRelative = weakRelative.promote();
2445 if (strongRelative != nullptr) {
2446 layerInfo->add_relatives(strongRelative->sequence);
2447 }
chaviwadc40c22018-07-10 16:57:27 -07002448 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002449
2450 LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,
2451 [&]() { return layerInfo->mutable_transparent_region(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002452
2453 layerInfo->set_layer_stack(getLayerStack());
2454 layerInfo->set_z(state.z);
2455
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002456 LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),
2457 [&]() {
2458 return layerInfo->mutable_requested_position();
2459 });
2460
chaviw766c9c52021-02-10 17:36:47 -08002461 LayerProtoHelper::writeSizeToProto(state.width, state.height,
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002462 [&]() { return layerInfo->mutable_size(); });
2463
chaviw766c9c52021-02-10 17:36:47 -08002464 LayerProtoHelper::writeToProto(state.crop, [&]() { return layerInfo->mutable_crop(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002465
2466 layerInfo->set_is_opaque(isOpaque(state));
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002467
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002468
2469 layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));
2470 LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
2471 LayerProtoHelper::writeToProto(state.color,
2472 [&]() { return layerInfo->mutable_requested_color(); });
2473 layerInfo->set_flags(state.flags);
2474
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002475 LayerProtoHelper::writeToProto(requestedTransform,
2476 layerInfo->mutable_requested_transform());
2477
2478 auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();
2479 if (parent != nullptr) {
2480 layerInfo->set_parent(parent->sequence);
2481 } else {
2482 layerInfo->set_parent(-1);
2483 }
2484
2485 auto zOrderRelativeOf = state.zOrderRelativeOf.promote();
2486 if (zOrderRelativeOf != nullptr) {
2487 layerInfo->set_z_order_relative_of(zOrderRelativeOf->sequence);
2488 } else {
2489 layerInfo->set_z_order_relative_of(-1);
2490 }
chaviw08f3cb22020-01-13 13:17:21 -08002491
2492 layerInfo->set_is_relative_of(state.isRelativeOf);
chaviw250bcbb2020-08-05 11:17:54 -07002493
2494 layerInfo->set_owner_uid(mOwnerUid);
chaviwadc40c22018-07-10 16:57:27 -07002495 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002496
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002497 if (traceFlags & SurfaceTracing::TRACE_INPUT) {
chaviw4c34a092020-07-08 11:30:06 -07002498 InputWindowInfo info;
2499 if (useDrawing) {
[1;3C2b9fc252021-02-04 16:16:50 -08002500 info = fillInputInfo({nullptr});
chaviw4c34a092020-07-08 11:30:06 -07002501 } else {
2502 info = state.inputInfo;
2503 }
2504
2505 LayerProtoHelper::writeToProto(info, state.touchableRegionCrop,
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002506 [&]() { return layerInfo->mutable_input_window_info(); });
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002507 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002508
2509 if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
2510 auto protoMap = layerInfo->mutable_metadata();
2511 for (const auto& entry : state.metadata.mMap) {
2512 (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());
2513 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002514 }
chaviw1d044282017-09-27 12:19:28 -07002515}
2516
Robert Carr2e102c92018-10-23 12:11:15 -07002517bool Layer::isRemovedFromCurrentState() const {
2518 return mRemovedFromCurrentState;
2519}
2520
chaviw39d01472021-04-08 14:26:24 -05002521ui::Transform Layer::getInputTransform() const {
2522 return getTransform();
2523}
2524
2525Rect Layer::getInputBounds() const {
2526 return getCroppedBufferSize(getDrawingState());
2527}
2528
[1;3C2b9fc252021-02-04 16:16:50 -08002529void Layer::fillInputFrameInfo(InputWindowInfo& info, const ui::Transform& toPhysicalDisplay) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002530 // Transform layer size to screen space and inset it by surface insets.
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002531 // If this is a portal window, set the touchableRegion to the layerBounds.
2532 Rect layerBounds = info.portalToDisplayId == ADISPLAY_ID_NONE
chaviw39d01472021-04-08 14:26:24 -05002533 ? getInputBounds()
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002534 : info.touchableRegion.getBounds();
Arthur Hungd20b2702019-01-14 18:16:16 +08002535 if (!layerBounds.isValid()) {
chaviw39d01472021-04-08 14:26:24 -05002536 layerBounds = getInputBounds();
Arthur Hungd20b2702019-01-14 18:16:16 +08002537 }
chaviw1ff3d1e2020-07-01 15:53:47 -07002538
chaviw7e72caf2020-12-02 16:50:43 -08002539 if (!layerBounds.isValid()) {
2540 // If the layer bounds is empty, set the frame to empty and clear the transform
2541 info.frameLeft = 0;
2542 info.frameTop = 0;
2543 info.frameRight = 0;
2544 info.frameBottom = 0;
2545 info.transform.reset();
2546 return;
2547 }
2548
chaviw39d01472021-04-08 14:26:24 -05002549 ui::Transform layerToDisplay = getInputTransform();
[1;3C2b9fc252021-02-04 16:16:50 -08002550 // Transform that takes window coordinates to unrotated display coordinates
2551 ui::Transform t = toPhysicalDisplay * layerToDisplay;
chaviw7e72caf2020-12-02 16:50:43 -08002552 int32_t xSurfaceInset = info.surfaceInset;
2553 int32_t ySurfaceInset = info.surfaceInset;
[1;3C2b9fc252021-02-04 16:16:50 -08002554 // Bring screenBounds into unrotated space
2555 Rect screenBounds = toPhysicalDisplay.transform(Rect{mScreenBounds});
chaviw7e72caf2020-12-02 16:50:43 -08002556
chaviw1ff3d1e2020-07-01 15:53:47 -07002557 const float xScale = t.getScaleX();
2558 const float yScale = t.getScaleY();
2559 if (xScale != 1.0f || yScale != 1.0f) {
chaviw1ff3d1e2020-07-01 15:53:47 -07002560 xSurfaceInset = std::round(xSurfaceInset * xScale);
2561 ySurfaceInset = std::round(ySurfaceInset * yScale);
2562 }
2563
Peiyong Lin74861ad2020-10-14 11:55:33 -07002564 // Transform the layer bounds from layer coordinate space to display coordinate space.
chaviw44a6d2b2020-09-08 17:14:16 -07002565 Rect transformedLayerBounds = t.transform(layerBounds);
Ady Abraham282f1d72019-07-24 18:05:56 -07002566
2567 // clamp inset to layer bounds
chaviw44a6d2b2020-09-08 17:14:16 -07002568 xSurfaceInset = (xSurfaceInset >= 0)
2569 ? std::min(xSurfaceInset, transformedLayerBounds.getWidth() / 2)
2570 : 0;
2571 ySurfaceInset = (ySurfaceInset >= 0)
2572 ? std::min(ySurfaceInset, transformedLayerBounds.getHeight() / 2)
2573 : 0;
Ady Abraham282f1d72019-07-24 18:05:56 -07002574
Robert Carra7242302020-09-01 18:26:29 -07002575 // inset while protecting from overflow TODO(b/161235021): What is going wrong
2576 // in the overflow scenario?
2577 {
2578 int32_t tmp;
chaviw44a6d2b2020-09-08 17:14:16 -07002579 if (!__builtin_add_overflow(transformedLayerBounds.left, xSurfaceInset, &tmp))
2580 transformedLayerBounds.left = tmp;
2581 if (!__builtin_sub_overflow(transformedLayerBounds.right, xSurfaceInset, &tmp))
2582 transformedLayerBounds.right = tmp;
2583 if (!__builtin_add_overflow(transformedLayerBounds.top, ySurfaceInset, &tmp))
2584 transformedLayerBounds.top = tmp;
2585 if (!__builtin_sub_overflow(transformedLayerBounds.bottom, ySurfaceInset, &tmp))
2586 transformedLayerBounds.bottom = tmp;
Robert Carra7242302020-09-01 18:26:29 -07002587 }
Vishnu Nair8033a492018-12-05 07:27:23 -08002588
chaviw44a6d2b2020-09-08 17:14:16 -07002589 // Compute the correct transform to send to input. This will allow it to transform the
2590 // input coordinates from display space into window space. Therefore, it needs to use the
2591 // final layer frame to create the inverse transform. Since surface insets are added later,
2592 // along with the overflow, the best way to ensure we get the correct transform is to use
2593 // the final frame calculated.
2594 // 1. Take the original transform set on the window and get the inverse transform. This is
2595 // used to get the final bounds in display space (ignorning the transform). Apply the
Peiyong Lin74861ad2020-10-14 11:55:33 -07002596 // inverse transform on the layerBounds to get the untransformed frame (in layer space)
chaviw44a6d2b2020-09-08 17:14:16 -07002597 // 2. Take the top and left of the untransformed frame to get the real position on screen.
2598 // Apply the layer transform on top/left so it includes any scale or rotation. These will
2599 // be the new translation values for the transform.
2600 // 3. Update the translation of the original transform to the new translation values.
2601 // 4. Send the inverse transform to input so the coordinates can be transformed back into
2602 // window space.
2603 ui::Transform inverseTransform = t.inverse();
2604 Rect nonTransformedBounds = inverseTransform.transform(transformedLayerBounds);
2605 vec2 translation = t.transform(nonTransformedBounds.left, nonTransformedBounds.top);
chaviw1ff3d1e2020-07-01 15:53:47 -07002606 ui::Transform inputTransform(t);
chaviw44a6d2b2020-09-08 17:14:16 -07002607 inputTransform.set(translation.x, translation.y);
chaviw1ff3d1e2020-07-01 15:53:47 -07002608 info.transform = inputTransform.inverse();
2609
chaviw39cfa2e2020-11-04 14:19:02 -08002610 // We need to send the layer bounds cropped to the screenbounds since the layer can be cropped.
2611 // The frame should be the area the user sees on screen since it's used for occlusion
2612 // detection.
chaviw39cfa2e2020-11-04 14:19:02 -08002613 transformedLayerBounds.intersect(screenBounds, &transformedLayerBounds);
2614 info.frameLeft = transformedLayerBounds.left;
2615 info.frameTop = transformedLayerBounds.top;
2616 info.frameRight = transformedLayerBounds.right;
2617 info.frameBottom = transformedLayerBounds.bottom;
2618
Vishnu Nair8033a492018-12-05 07:27:23 -08002619 // Position the touchable region relative to frame screen location and restrict it to frame
2620 // bounds.
chaviw44a6d2b2020-09-08 17:14:16 -07002621 info.touchableRegion = inputTransform.transform(info.touchableRegion);
chaviw7e72caf2020-12-02 16:50:43 -08002622}
2623
[1;3C2b9fc252021-02-04 16:16:50 -08002624InputWindowInfo Layer::fillInputInfo(const sp<DisplayDevice>& display) {
chaviw7e72caf2020-12-02 16:50:43 -08002625 if (!hasInputInfo()) {
2626 mDrawingState.inputInfo.name = getName();
2627 mDrawingState.inputInfo.ownerUid = mOwnerUid;
2628 mDrawingState.inputInfo.ownerPid = mOwnerPid;
2629 mDrawingState.inputInfo.inputFeatures = InputWindowInfo::Feature::NO_INPUT_CHANNEL;
2630 mDrawingState.inputInfo.flags = InputWindowInfo::Flag::NOT_TOUCH_MODAL;
2631 mDrawingState.inputInfo.displayId = getLayerStack();
2632 }
2633
2634 InputWindowInfo info = mDrawingState.inputInfo;
2635 info.id = sequence;
2636
2637 if (info.displayId == ADISPLAY_ID_NONE) {
2638 info.displayId = getLayerStack();
2639 }
2640
[1;3C2b9fc252021-02-04 16:16:50 -08002641 // Transform that goes from "logical(rotated)" display to physical/unrotated display.
2642 // This is for when inputflinger operates in physical display-space.
2643 ui::Transform toPhysicalDisplay;
2644 if (display) {
2645 toPhysicalDisplay = display->getTransform();
2646 }
2647 fillInputFrameInfo(info, toPhysicalDisplay);
chaviw7e72caf2020-12-02 16:50:43 -08002648
Robert Carr5dc426e2020-06-10 14:29:14 -07002649 // For compatibility reasons we let layers which can receive input
2650 // receive input before they have actually submitted a buffer. Because
2651 // of this we use canReceiveInput instead of isVisible to check the
2652 // policy-visibility, ignoring the buffer state. However for layers with
2653 // hasInputInfo()==false we can use the real visibility state.
2654 // We are just using these layers for occlusion detection in
2655 // InputDispatcher, and obviously if they aren't visible they can't occlude
2656 // anything.
2657 info.visible = hasInputInfo() ? canReceiveInput() : isVisible();
Bernardo Rufinoea97d182020-08-19 14:43:14 +01002658 info.alpha = getAlpha();
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002659
2660 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2661 if (info.replaceTouchableRegionWithCrop) {
2662 if (cropLayer == nullptr) {
[1;3C2b9fc252021-02-04 16:16:50 -08002663 info.touchableRegion = Region(toPhysicalDisplay.transform(Rect{mScreenBounds}));
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002664 } else {
[1;3C2b9fc252021-02-04 16:16:50 -08002665 info.touchableRegion =
2666 Region(toPhysicalDisplay.transform(Rect{cropLayer->mScreenBounds}));
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002667 }
2668 } else if (cropLayer != nullptr) {
[1;3C2b9fc252021-02-04 16:16:50 -08002669 info.touchableRegion = info.touchableRegion.intersect(
2670 toPhysicalDisplay.transform(Rect{cropLayer->mScreenBounds}));
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002671 }
2672
chaviwaf87b3e2019-10-01 16:59:28 -07002673 // If the layer is a clone, we need to crop the input region to cloned root to prevent
2674 // touches from going outside the cloned area.
2675 if (isClone()) {
2676 sp<Layer> clonedRoot = getClonedRoot();
2677 if (clonedRoot != nullptr) {
[1;3C2b9fc252021-02-04 16:16:50 -08002678 Rect rect = toPhysicalDisplay.transform(Rect{clonedRoot->mScreenBounds});
chaviwaf87b3e2019-10-01 16:59:28 -07002679 info.touchableRegion = info.touchableRegion.intersect(rect);
2680 }
2681 }
2682
Robert Carr720e5062018-07-30 17:45:14 -07002683 return info;
2684}
2685
chaviwaf87b3e2019-10-01 16:59:28 -07002686sp<Layer> Layer::getClonedRoot() {
2687 if (mClonedChild != nullptr) {
2688 return this;
2689 }
2690 if (mDrawingParent == nullptr || mDrawingParent.promote() == nullptr) {
2691 return nullptr;
2692 }
2693 return mDrawingParent.promote()->getClonedRoot();
2694}
2695
Robert Carredd13602020-04-13 17:24:34 -07002696bool Layer::hasInputInfo() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002697 return mDrawingState.inputInfo.token != nullptr;
Robert Carr720e5062018-07-30 17:45:14 -07002698}
2699
chaviw3e727cd2019-01-31 13:41:05 -08002700bool Layer::canReceiveInput() const {
Vishnu Nair82353e92019-09-12 12:38:47 -07002701 return !isHiddenByPolicy();
chaviw3e727cd2019-01-31 13:41:05 -08002702}
2703
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002704compositionengine::OutputLayer* Layer::findOutputLayerForDisplay(
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002705 const DisplayDevice* display) const {
2706 if (!display) return nullptr;
Lloyd Piquede196652020-01-22 17:29:58 -08002707 return display->getCompositionDisplay()->getOutputLayerForLayer(getCompositionEngineLayerFE());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002708}
2709
Dominik Laskowskib7251f42020-04-20 17:42:59 -07002710Region Layer::getVisibleRegion(const DisplayDevice* display) const {
2711 const auto outputLayer = findOutputLayerForDisplay(display);
2712 return outputLayer ? outputLayer->getState().visibleRegion : Region();
Lloyd Piquea2468662019-03-07 21:31:06 -08002713}
2714
chaviwb4c6e582019-08-16 14:35:07 -07002715void Layer::setInitialValuesForClone(const sp<Layer>& clonedFrom) {
2716 // copy drawing state from cloned layer
2717 mDrawingState = clonedFrom->mDrawingState;
2718 mClonedFrom = clonedFrom;
chaviwb4c6e582019-08-16 14:35:07 -07002719}
chaviw74b03172019-08-19 11:09:03 -07002720
2721void Layer::updateMirrorInfo() {
2722 if (mClonedChild == nullptr || !mClonedChild->isClonedFromAlive()) {
2723 // If mClonedChild is null, there is nothing to mirror. If isClonedFromAlive returns false,
2724 // it means that there is a clone, but the layer it was cloned from has been destroyed. In
2725 // that case, we want to delete the reference to the clone since we want it to get
2726 // destroyed. The root, this layer, will still be around since the client can continue
2727 // to hold a reference, but no cloned layers will be displayed.
2728 mClonedChild = nullptr;
2729 return;
2730 }
2731
2732 std::map<sp<Layer>, sp<Layer>> clonedLayersMap;
2733 // If the real layer exists and is in current state, add the clone as a child of the root.
2734 // There's no need to remove from drawingState when the layer is offscreen since currentState is
2735 // copied to drawingState for the root layer. So the clonedChild is always removed from
2736 // drawingState and then needs to be added back each traversal.
2737 if (!mClonedChild->getClonedFrom()->isRemovedFromCurrentState()) {
2738 addChildToDrawing(mClonedChild);
2739 }
2740
2741 mClonedChild->updateClonedDrawingState(clonedLayersMap);
2742 mClonedChild->updateClonedChildren(this, clonedLayersMap);
2743 mClonedChild->updateClonedRelatives(clonedLayersMap);
2744}
2745
2746void Layer::updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2747 // If the layer the clone was cloned from is alive, copy the content of the drawingState
2748 // to the clone. If the real layer is no longer alive, continue traversing the children
2749 // since we may be able to pull out other children that are still alive.
2750 if (isClonedFromAlive()) {
2751 sp<Layer> clonedFrom = getClonedFrom();
2752 mDrawingState = clonedFrom->mDrawingState;
chaviw74b03172019-08-19 11:09:03 -07002753 clonedLayersMap.emplace(clonedFrom, this);
2754 }
2755
2756 // The clone layer may have children in drawingState since they may have been created and
2757 // added from a previous request to updateMirorInfo. This is to ensure we don't recreate clones
2758 // that already exist, since we can just re-use them.
2759 // The drawingChildren will not get overwritten by the currentChildren since the clones are
2760 // not updated in the regular traversal. They are skipped since the root will lose the
2761 // reference to them when it copies its currentChildren to drawing.
2762 for (sp<Layer>& child : mDrawingChildren) {
2763 child->updateClonedDrawingState(clonedLayersMap);
2764 }
2765}
2766
2767void Layer::updateClonedChildren(const sp<Layer>& mirrorRoot,
2768 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2769 mDrawingChildren.clear();
2770
2771 if (!isClonedFromAlive()) {
2772 return;
2773 }
2774
2775 sp<Layer> clonedFrom = getClonedFrom();
2776 for (sp<Layer>& child : clonedFrom->mDrawingChildren) {
2777 if (child == mirrorRoot) {
2778 // This is to avoid cyclical mirroring.
2779 continue;
2780 }
2781 sp<Layer> clonedChild = clonedLayersMap[child];
2782 if (clonedChild == nullptr) {
2783 clonedChild = child->createClone();
2784 clonedLayersMap[child] = clonedChild;
2785 }
2786 addChildToDrawing(clonedChild);
2787 clonedChild->updateClonedChildren(mirrorRoot, clonedLayersMap);
2788 }
2789}
2790
chaviwaf87b3e2019-10-01 16:59:28 -07002791void Layer::updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2792 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2793 if (cropLayer != nullptr) {
2794 if (clonedLayersMap.count(cropLayer) == 0) {
2795 // Real layer had a crop layer but it's not in the cloned hierarchy. Just set to
2796 // self as crop layer to avoid going outside bounds.
2797 mDrawingState.touchableRegionCrop = this;
2798 } else {
2799 const sp<Layer>& clonedCropLayer = clonedLayersMap.at(cropLayer);
2800 mDrawingState.touchableRegionCrop = clonedCropLayer;
2801 }
2802 }
2803 // Cloned layers shouldn't handle watch outside since their z order is not determined by
2804 // WM or the client.
Michael Wright44753b12020-07-08 13:48:11 +01002805 mDrawingState.inputInfo.flags &= ~InputWindowInfo::Flag::WATCH_OUTSIDE_TOUCH;
chaviwaf87b3e2019-10-01 16:59:28 -07002806}
2807
2808void Layer::updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
chaviw74b03172019-08-19 11:09:03 -07002809 mDrawingState.zOrderRelativeOf = nullptr;
2810 mDrawingState.zOrderRelatives.clear();
2811
2812 if (!isClonedFromAlive()) {
2813 return;
2814 }
2815
chaviwaf87b3e2019-10-01 16:59:28 -07002816 const sp<Layer>& clonedFrom = getClonedFrom();
chaviw74b03172019-08-19 11:09:03 -07002817 for (wp<Layer>& relativeWeak : clonedFrom->mDrawingState.zOrderRelatives) {
chaviwaf87b3e2019-10-01 16:59:28 -07002818 const sp<Layer>& relative = relativeWeak.promote();
2819 if (clonedLayersMap.count(relative) > 0) {
2820 auto& clonedRelative = clonedLayersMap.at(relative);
chaviw74b03172019-08-19 11:09:03 -07002821 mDrawingState.zOrderRelatives.add(clonedRelative);
2822 }
2823 }
2824
2825 // Check if the relativeLayer for the real layer is part of the cloned hierarchy.
2826 // It's possible that the layer it's relative to is outside the requested cloned hierarchy.
2827 // In that case, we treat the layer as if the relativeOf has been removed. This way, it will
2828 // still traverse the children, but the layer with the missing relativeOf will not be shown
2829 // on screen.
chaviwaf87b3e2019-10-01 16:59:28 -07002830 const sp<Layer>& relativeOf = clonedFrom->mDrawingState.zOrderRelativeOf.promote();
2831 if (clonedLayersMap.count(relativeOf) > 0) {
2832 const sp<Layer>& clonedRelativeOf = clonedLayersMap.at(relativeOf);
chaviw74b03172019-08-19 11:09:03 -07002833 mDrawingState.zOrderRelativeOf = clonedRelativeOf;
2834 }
2835
chaviwaf87b3e2019-10-01 16:59:28 -07002836 updateClonedInputInfo(clonedLayersMap);
2837
chaviw74b03172019-08-19 11:09:03 -07002838 for (sp<Layer>& child : mDrawingChildren) {
2839 child->updateClonedRelatives(clonedLayersMap);
2840 }
2841}
2842
2843void Layer::addChildToDrawing(const sp<Layer>& layer) {
2844 mDrawingChildren.add(layer);
2845 layer->mDrawingParent = this;
2846}
2847
Steven Thomas62a4cf82020-01-31 12:04:03 -08002848Layer::FrameRateCompatibility Layer::FrameRate::convertCompatibility(int8_t compatibility) {
2849 switch (compatibility) {
2850 case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT:
2851 return FrameRateCompatibility::Default;
2852 case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE:
2853 return FrameRateCompatibility::ExactOrMultiple;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002854 case ANATIVEWINDOW_FRAME_RATE_EXACT:
2855 return FrameRateCompatibility::Exact;
Steven Thomas62a4cf82020-01-31 12:04:03 -08002856 default:
2857 LOG_ALWAYS_FATAL("Invalid frame rate compatibility value %d", compatibility);
2858 return FrameRateCompatibility::Default;
2859 }
2860}
2861
Marin Shalamanovc5986772021-03-16 16:09:49 +01002862scheduler::Seamlessness Layer::FrameRate::convertChangeFrameRateStrategy(int8_t strategy) {
2863 switch (strategy) {
2864 case ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS:
2865 return Seamlessness::OnlySeamless;
2866 case ANATIVEWINDOW_CHANGE_FRAME_RATE_ALWAYS:
2867 return Seamlessness::SeamedAndSeamless;
2868 default:
2869 LOG_ALWAYS_FATAL("Invalid change frame sate strategy value %d", strategy);
2870 return Seamlessness::Default;
2871 }
2872}
2873
chaviwc5676c62020-09-18 15:01:04 -07002874bool Layer::getPrimaryDisplayOnly() const {
2875 const State& s(mDrawingState);
2876 if (s.flags & layer_state_t::eLayerSkipScreenshot) {
2877 return true;
2878 }
2879
2880 sp<Layer> parent = mDrawingParent.promote();
2881 return parent == nullptr ? false : parent->getPrimaryDisplayOnly();
2882}
2883
Mathias Agopian13127d82013-03-05 17:47:11 -08002884// ---------------------------------------------------------------------------
2885
Marin Shalamanov46084422020-10-13 12:33:42 +02002886std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate) {
2887 return stream << "{rate=" << rate.rate
2888 << " type=" << Layer::frameRateCompatibilityString(rate.type)
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01002889 << " seamlessness=" << toString(rate.seamlessness) << "}";
Marin Shalamanov46084422020-10-13 12:33:42 +02002890}
2891
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002892}; // namespace android
Mathias Agopian3f844832013-08-07 21:24:32 -07002893
2894#if defined(__gl_h_)
2895#error "don't include gl/gl.h in this file"
2896#endif
2897
2898#if defined(__gl2_h_)
2899#error "don't include gl2/gl2.h in this file"
2900#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08002901
2902// TODO(b/129481165): remove the #pragma below and fix conversion issues
2903#pragma clang diagnostic pop // ignored "-Wconversion"