blob: 4ac868e6a501a73f33d359d46cbc9c2f96882ca9 [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
Yiwei Zhang5434a782018-12-05 18:06:32 -080028#include <android-base/stringprintf.h>
Vishnu Nair0f085c62019-08-30 08:49:12 -070029#include <binder/IPCThreadState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080030#include <compositionengine/Display.h>
Lloyd Pique0b785d82018-12-04 17:25:27 -080031#include <compositionengine/Layer.h>
Lloyd Piquea83776c2019-01-29 18:42:32 -080032#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080033#include <compositionengine/OutputLayer.h>
34#include <compositionengine/impl/OutputLayerCompositionState.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070035#include <cutils/compiler.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070036#include <cutils/native_handle.h>
Mathias Agopiana67932f2011-04-20 14:20:59 -070037#include <cutils/properties.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080038#include <gui/BufferItem.h>
39#include <gui/LayerDebugInfo.h>
40#include <gui/Surface.h>
Alec Mourie60041e2019-06-14 18:59:51 -070041#include <math.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080042#include <renderengine/RenderEngine.h>
Alec Mourie60041e2019-06-14 18:59:51 -070043#include <stdint.h>
44#include <stdlib.h>
45#include <sys/types.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080046#include <ui/DebugUtils.h>
47#include <ui/GraphicBuffer.h>
48#include <ui/PixelFormat.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080049#include <utils/Errors.h>
50#include <utils/Log.h>
Jesse Hall399184a2014-03-03 15:42:54 -080051#include <utils/NativeHandle.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080052#include <utils/StopWatch.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080053#include <utils/Trace.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080054
Alec Mourie60041e2019-06-14 18:59:51 -070055#include <algorithm>
56#include <mutex>
57#include <sstream>
58
Yiwei Zhang60d1a192018-03-07 14:52:28 -080059#include "BufferLayer.h"
Valerie Haudd0b7572019-01-29 14:59:27 -080060#include "ColorLayer.h"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020061#include "Colorizer.h"
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -070062#include "DisplayDevice.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080063#include "DisplayHardware/HWComposer.h"
Mikael Pessa90092f42019-08-26 17:22:04 -070064#include "FrameTracer/FrameTracer.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080065#include "LayerProtoHelper.h"
Fabien Sanglard7b1563a2016-10-13 12:05:28 -070066#include "LayerRejecter.h"
Dan Stozab9b08832014-03-13 11:55:57 -070067#include "MonitoredProducer.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080068#include "SurfaceFlinger.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080069#include "TimeStats/TimeStats.h"
Mathias Agopian1b031492012-06-20 17:51:20 -070070
David Sodman41fdfc92017-11-06 16:09:56 -080071#define DEBUG_RESIZE 0
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080072
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080073namespace android {
74
Yiwei Zhang5434a782018-12-05 18:06:32 -080075using base::StringAppendF;
76
Lloyd Piquef1c675b2018-09-12 20:45:39 -070077std::atomic<int32_t> Layer::sSequence{1};
Mathias Agopian13127d82013-03-05 17:47:11 -080078
Lloyd Pique42ab75e2018-09-12 20:46:03 -070079Layer::Layer(const LayerCreationArgs& args)
Ady Abraham8f1ee7f2019-04-05 10:32:50 -070080 : mFlinger(args.flinger),
81 mName(args.name),
82 mClientRef(args.client),
83 mWindowType(args.metadata.getInt32(METADATA_WINDOW_TYPE, 0)) {
Mathias Agopian4d9b8222013-03-12 17:11:48 -070084
85 uint32_t layerFlags = 0;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070086 if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
87 if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
88 if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;
Mathias Agopian4d9b8222013-03-12 17:11:48 -070089
Lloyd Pique0449b0f2018-12-20 16:23:45 -080090 mCurrentState.active_legacy.w = args.w;
91 mCurrentState.active_legacy.h = args.h;
92 mCurrentState.flags = layerFlags;
93 mCurrentState.active_legacy.transform.set(0, 0);
94 mCurrentState.crop_legacy.makeInvalid();
95 mCurrentState.requestedCrop_legacy = mCurrentState.crop_legacy;
96 mCurrentState.z = 0;
97 mCurrentState.color.a = 1.0f;
98 mCurrentState.layerStack = 0;
99 mCurrentState.sequence = 0;
100 mCurrentState.requested_legacy = mCurrentState.active_legacy;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800101 mCurrentState.active.w = UINT32_MAX;
102 mCurrentState.active.h = UINT32_MAX;
103 mCurrentState.active.transform.set(0, 0);
104 mCurrentState.transform = 0;
105 mCurrentState.transformToDisplayInverse = false;
106 mCurrentState.crop.makeInvalid();
107 mCurrentState.acquireFence = new Fence(-1);
108 mCurrentState.dataspace = ui::Dataspace::UNKNOWN;
109 mCurrentState.hdrMetadata.validTypes = 0;
Marissa Wall7e0a01f2019-08-14 14:29:25 -0700110 mCurrentState.surfaceDamageRegion = Region::INVALID_REGION;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800111 mCurrentState.cornerRadius = 0.0f;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800112 mCurrentState.backgroundBlurRadius = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800113 mCurrentState.api = -1;
114 mCurrentState.hasColorTransform = false;
Peiyong Linc502cb72019-03-01 15:00:23 -0800115 mCurrentState.colorSpaceAgnostic = false;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100116 mCurrentState.frameRateSelectionPriority = PRIORITY_UNSET;
Evan Roskya1f1e152019-01-24 16:17:46 -0800117 mCurrentState.metadata = args.metadata;
Vishnu Nairf37dcfb2019-11-16 07:37:09 -0800118 mCurrentState.shadowRadius = 0.f;
Steven Thomas3172e202020-01-06 19:25:30 -0800119 mCurrentState.frameRate = 0.f;
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700120
121 // drawing state & current state are identical
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800122 mDrawingState = mCurrentState;
Jamie Gennis6547ff42013-07-16 20:12:42 -0700123
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800124 CompositorTiming compositorTiming;
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700125 args.flinger->getCompositorTiming(&compositorTiming);
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800126 mFrameEventHistory.initializeCompositorTiming(compositorTiming);
Jorim Jaggibd6480f2018-08-10 14:37:31 +0200127 mFrameTracker.setDisplayRefreshPeriod(compositorTiming.interval);
Robert Carr2e102c92018-10-23 12:11:15 -0700128
Vishnu Nair0f085c62019-08-30 08:49:12 -0700129 mCallingPid = args.callingPid;
130 mCallingUid = args.callingUid;
Dominik Laskowski75848362019-11-11 17:57:20 -0800131}
132
133void Layer::onFirstRef() {
134 mFlinger->onLayerFirstRef(this);
Dan Stoza436ccf32018-06-21 12:10:12 -0700135}
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700136
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700137Layer::~Layer() {
David Sodman577c8962017-12-08 14:50:53 -0800138 sp<Client> c(mClientRef.promote());
139 if (c != 0) {
140 c->detachLayer(this);
141 }
142
Jorim Jaggi10c985e2018-10-23 11:17:45 +0000143 mFrameTracker.logAndResetStats(mName);
chaviw74d90ad2019-04-26 14:45:26 -0700144 mFlinger->onLayerDestroyed(this);
Mathias Agopian96f08192010-06-02 23:28:45 -0700145}
146
Vishnu Nair0f085c62019-08-30 08:49:12 -0700147LayerCreationArgs::LayerCreationArgs(SurfaceFlinger* flinger, const sp<Client>& client,
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700148 std::string name, uint32_t w, uint32_t h, uint32_t flags,
Vishnu Nair0f085c62019-08-30 08:49:12 -0700149 LayerMetadata metadata)
150 : flinger(flinger),
151 client(client),
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700152 name(std::move(name)),
Vishnu Nair0f085c62019-08-30 08:49:12 -0700153 w(w),
154 h(h),
155 flags(flags),
156 metadata(std::move(metadata)) {
157 IPCThreadState* ipc = IPCThreadState::self();
158 callingPid = ipc->getCallingPid();
159 callingUid = ipc->getCallingUid();
160}
161
Mathias Agopian13127d82013-03-05 17:47:11 -0800162// ---------------------------------------------------------------------------
163// callbacks
164// ---------------------------------------------------------------------------
165
David Sodmaneb085e02017-10-05 18:49:04 -0700166/*
167 * onLayerDisplayed is only meaningful for BufferLayer, but, is called through
168 * Layer. So, the implementation is done in BufferLayer. When called on a
169 * ColorLayer object, it's essentially a NOP.
170 */
David Sodmaneb085e02017-10-05 18:49:04 -0700171void Layer::onLayerDisplayed(const sp<Fence>& /*releaseFence*/) {}
Mathias Agopian13127d82013-03-05 17:47:11 -0800172
chaviw43cb3cb2019-05-31 15:23:41 -0700173void Layer::removeRemoteSyncPoints() {
174 for (auto& point : mRemoteSyncPoints) {
175 point->setTransactionApplied();
176 }
177 mRemoteSyncPoints.clear();
178
179 {
chaviw43cb3cb2019-05-31 15:23:41 -0700180 for (State pendingState : mPendingStates) {
181 pendingState.barrierLayer_legacy = nullptr;
182 }
183 }
184}
185
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700186void Layer::removeRelativeZ(const std::vector<Layer*>& layersInTree) {
187 if (mCurrentState.zOrderRelativeOf == nullptr) {
188 return;
189 }
Robert Carr2e102c92018-10-23 12:11:15 -0700190
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700191 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
192 if (strongRelative == nullptr) {
193 setZOrderRelativeOf(nullptr);
194 return;
195 }
196
197 if (!std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
198 strongRelative->removeZOrderRelative(this);
199 mFlinger->setTransactionFlags(eTraversalNeeded);
chaviw606e5cf2019-03-01 10:12:10 -0800200 setZOrderRelativeOf(nullptr);
Robert Carr5edb1ad2017-04-25 10:54:24 -0700201 }
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700202}
203
204void Layer::removeFromCurrentState() {
205 mRemovedFromCurrentState = true;
Rob Carr4bba3702018-10-08 21:53:30 +0000206
Robert Carr2e102c92018-10-23 12:11:15 -0700207 // Since we are no longer reachable from CurrentState SurfaceFlinger
208 // will no longer invoke doTransaction for us, and so we will
209 // never finish applying transactions. We signal the sync point
210 // now so that another layer will not become indefinitely
211 // blocked.
chaviw43cb3cb2019-05-31 15:23:41 -0700212 removeRemoteSyncPoints();
Robert Carr2e102c92018-10-23 12:11:15 -0700213
214 {
215 Mutex::Autolock syncLock(mLocalSyncPointMutex);
216 for (auto& point : mLocalSyncPoints) {
217 point->setFrameAvailable();
218 }
219 mLocalSyncPoints.clear();
220 }
221
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800222 mFlinger->markLayerPendingRemovalLocked(this);
Chia-I Wuc6657022017-08-15 11:18:17 -0700223}
Chia-I Wu38512252017-05-17 14:36:16 -0700224
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700225void Layer::onRemovedFromCurrentState() {
226 auto layersInTree = getLayersInTree(LayerVector::StateSet::Current);
227 std::sort(layersInTree.begin(), layersInTree.end());
228 for (const auto& layer : layersInTree) {
229 layer->removeFromCurrentState();
230 layer->removeRelativeZ(layersInTree);
231 }
232}
233
chaviw61626f22018-11-15 16:26:27 -0800234void Layer::addToCurrentState() {
235 mRemovedFromCurrentState = false;
236
237 for (const auto& child : mCurrentChildren) {
238 child->addToCurrentState();
239 }
240}
241
Mathias Agopian13127d82013-03-05 17:47:11 -0800242// ---------------------------------------------------------------------------
243// set-up
244// ---------------------------------------------------------------------------
245
chaviw13fdc492017-06-27 12:40:18 -0700246bool Layer::getPremultipledAlpha() const {
247 return mPremultipliedAlpha;
248}
249
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700250sp<IBinder> Layer::getHandle() {
Mathias Agopian13127d82013-03-05 17:47:11 -0800251 Mutex::Autolock _l(mLock);
Robert Carrc0df3122019-04-11 13:18:21 -0700252 if (mGetHandleCalled) {
253 ALOGE("Get handle called twice" );
254 return nullptr;
255 }
256 mGetHandleCalled = true;
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700257 return new Handle(mFlinger, this);
Mathias Agopian13127d82013-03-05 17:47:11 -0800258}
259
260// ---------------------------------------------------------------------------
261// h/w composer set-up
262// ---------------------------------------------------------------------------
263
Mathias Agopianf3e85d42013-05-10 18:01:12 -0700264static Rect reduce(const Rect& win, const Region& exclude) {
265 if (CC_LIKELY(exclude.isEmpty())) {
266 return win;
267 }
268 if (exclude.isRect()) {
269 return win.reduce(exclude.getBounds());
270 }
271 return Region(win).subtract(exclude).getBounds();
272}
273
Dan Stoza80d61162017-12-20 15:57:52 -0800274static FloatRect reduce(const FloatRect& win, const Region& exclude) {
275 if (CC_LIKELY(exclude.isEmpty())) {
276 return win;
277 }
278 // Convert through Rect (by rounding) for lack of FloatRegion
279 return Region(Rect{win}).subtract(exclude).getBounds().toFloatRect();
280}
281
Vishnu Nair4351ad52019-02-11 14:13:02 -0800282Rect Layer::getScreenBounds(bool reduceTransparentRegion) const {
Vishnu Nairf0c28512019-02-08 12:40:28 -0800283 if (!reduceTransparentRegion) {
284 return Rect{mScreenBounds};
285 }
286
287 FloatRect bounds = getBounds();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800288 ui::Transform t = getTransform();
Vishnu Nair60356342018-11-13 13:00:45 -0800289 // Transform to screen space.
290 bounds = t.transform(bounds);
291 return Rect{bounds};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700292}
293
Vishnu Nair4351ad52019-02-11 14:13:02 -0800294FloatRect Layer::getBounds() const {
Alec Mourib416efd2018-09-06 21:01:59 +0000295 const State& s(getDrawingState());
Vishnu Nair4351ad52019-02-11 14:13:02 -0800296 return getBounds(getActiveTransparentRegion(s));
Michael Lentine6c925ed2014-09-26 17:55:01 -0700297}
298
Vishnu Nairf0c28512019-02-08 12:40:28 -0800299FloatRect Layer::getBounds(const Region& activeTransparentRegion) const {
300 // Subtract the transparent region and snap to the bounds.
301 return reduce(mBounds, activeTransparentRegion);
302}
303
Vishnu Nairc652ff82019-03-15 12:48:54 -0700304ui::Transform Layer::getBufferScaleTransform() const {
Vishnu Nair4351ad52019-02-11 14:13:02 -0800305 // If the layer is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g.
306 // it isFixedSize) then there may be additional scaling not accounted
Vishnu Nairc652ff82019-03-15 12:48:54 -0700307 // for in the layer transform.
chaviwd62d3062019-09-04 14:48:02 -0700308 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700309 return {};
Vishnu Nair4351ad52019-02-11 14:13:02 -0800310 }
311
Marissa Wall290ad082019-03-06 13:23:47 -0800312 // If the layer is a buffer state layer, the active width and height
313 // could be infinite. In that case, return the effective transform.
314 const uint32_t activeWidth = getActiveWidth(getDrawingState());
315 const uint32_t activeHeight = getActiveHeight(getDrawingState());
316 if (activeWidth >= UINT32_MAX && activeHeight >= UINT32_MAX) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700317 return {};
Marissa Wall290ad082019-03-06 13:23:47 -0800318 }
319
chaviwd62d3062019-09-04 14:48:02 -0700320 int bufferWidth = getBuffer()->getWidth();
321 int bufferHeight = getBuffer()->getHeight();
Vishnu Nairc652ff82019-03-15 12:48:54 -0700322
chaviw4244e032019-09-04 11:27:49 -0700323 if (getBufferTransform() & NATIVE_WINDOW_TRANSFORM_ROT_90) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700324 std::swap(bufferWidth, bufferHeight);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800325 }
Vishnu Nairc652ff82019-03-15 12:48:54 -0700326
Marissa Wall290ad082019-03-06 13:23:47 -0800327 float sx = activeWidth / static_cast<float>(bufferWidth);
328 float sy = activeHeight / static_cast<float>(bufferHeight);
329
Vishnu Nair4351ad52019-02-11 14:13:02 -0800330 ui::Transform extraParentScaling;
331 extraParentScaling.set(sx, 0, 0, sy);
Vishnu Nairc652ff82019-03-15 12:48:54 -0700332 return extraParentScaling;
333}
334
335ui::Transform Layer::getTransformWithScale(const ui::Transform& bufferScaleTransform) const {
336 // We need to mirror this scaling to child surfaces or we will break the contract where WM can
337 // treat child surfaces as pixels in the parent surface.
chaviwd62d3062019-09-04 14:48:02 -0700338 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700339 return mEffectiveTransform;
340 }
341 return mEffectiveTransform * bufferScaleTransform;
342}
343
344FloatRect Layer::getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const {
345 // We need the pre scaled layer bounds when computing child bounds to make sure the child is
346 // cropped to its parent layer after any buffer transform scaling is applied.
chaviwd62d3062019-09-04 14:48:02 -0700347 if (!isFixedSize() || getBuffer() == nullptr) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700348 return mBounds;
349 }
350 return bufferScaleTransform.inverse().transform(mBounds);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800351}
352
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700353void Layer::computeBounds(FloatRect parentBounds, ui::Transform parentTransform,
354 float parentShadowRadius) {
Vishnu Nair4351ad52019-02-11 14:13:02 -0800355 const State& s(getDrawingState());
356
357 // Calculate effective layer transform
358 mEffectiveTransform = parentTransform * getActiveTransform(s);
359
360 // Transform parent bounds to layer space
361 parentBounds = getActiveTransform(s).inverse().transform(parentBounds);
362
Vishnu Nairc652ff82019-03-15 12:48:54 -0700363 // Calculate source bounds
Vishnu Nair4351ad52019-02-11 14:13:02 -0800364 mSourceBounds = computeSourceBounds(parentBounds);
365
366 // Calculate bounds by croping diplay frame with layer crop and parent bounds
367 FloatRect bounds = mSourceBounds;
368 const Rect layerCrop = getCrop(s);
369 if (!layerCrop.isEmpty()) {
370 bounds = mSourceBounds.intersect(layerCrop.toFloatRect());
371 }
372 bounds = bounds.intersect(parentBounds);
373
374 mBounds = bounds;
375 mScreenBounds = mEffectiveTransform.transform(mBounds);
Vishnu Nairc652ff82019-03-15 12:48:54 -0700376
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700377 // Use the layer's own shadow radius if set. Otherwise get the radius from
378 // parent.
379 if (s.shadowRadius > 0.f) {
380 mEffectiveShadowRadius = s.shadowRadius;
381 } else {
382 mEffectiveShadowRadius = parentShadowRadius;
383 }
384
385 // Shadow radius is passed down to only one layer so if the layer can draw shadows,
386 // don't pass it to its children.
387 const float childShadowRadius = canDrawShadows() ? 0.f : mEffectiveShadowRadius;
388
Vishnu Nairc652ff82019-03-15 12:48:54 -0700389 // Add any buffer scaling to the layer's children.
390 ui::Transform bufferScaleTransform = getBufferScaleTransform();
Vishnu Nair4351ad52019-02-11 14:13:02 -0800391 for (const sp<Layer>& child : mDrawingChildren) {
Vishnu Nairc652ff82019-03-15 12:48:54 -0700392 child->computeBounds(getBoundsPreScaling(bufferScaleTransform),
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700393 getTransformWithScale(bufferScaleTransform), childShadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800394 }
395}
396
Vishnu Nair60356342018-11-13 13:00:45 -0800397Rect Layer::getCroppedBufferSize(const State& s) const {
398 Rect size = getBufferSize(s);
399 Rect crop = getCrop(s);
400 if (!crop.isEmpty() && size.isValid()) {
401 size.intersect(crop, &size);
402 } else if (!crop.isEmpty()) {
403 size = crop;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700404 }
Vishnu Nair60356342018-11-13 13:00:45 -0800405 return size;
Mathias Agopian13127d82013-03-05 17:47:11 -0800406}
407
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700408void Layer::setupRoundedCornersCropCoordinates(Rect win,
409 const FloatRect& roundedCornersCrop) const {
410 // Translate win by the rounded corners rect coordinates, to have all values in
411 // layer coordinate space.
412 win.left -= roundedCornersCrop.left;
413 win.right -= roundedCornersCrop.left;
414 win.top -= roundedCornersCrop.top;
415 win.bottom -= roundedCornersCrop.top;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700416}
417
Lloyd Piquec6687342019-03-07 21:34:57 -0800418void Layer::latchBasicGeometry(compositionengine::LayerFECompositionState& compositionState) const {
419 const auto& drawingState{getDrawingState()};
420 const uint32_t layerStack = getLayerStack();
421 const auto alpha = static_cast<float>(getAlpha());
422 const bool opaque = isOpaque(drawingState);
423 const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f;
424
425 auto blendMode = Hwc2::IComposerClient::BlendMode::NONE;
426 if (!opaque || alpha != 1.0f) {
427 blendMode = mPremultipliedAlpha ? Hwc2::IComposerClient::BlendMode::PREMULTIPLIED
428 : Hwc2::IComposerClient::BlendMode::COVERAGE;
429 }
430
431 // TODO(b/121291683): Instead of filling in a passed-in compositionState
432 // structure, switch to Layer owning the structure and have
433 // CompositionEngine be able to get a reference to it.
434
435 compositionState.layerStackId =
436 (layerStack != ~0u) ? std::make_optional(layerStack) : std::nullopt;
437 compositionState.internalOnly = getPrimaryDisplayOnly();
438 compositionState.isVisible = isVisible();
439 compositionState.isOpaque = opaque && !usesRoundedCorners && alpha == 1.f;
Vishnu Naira483b4a2019-12-12 15:07:52 -0800440 compositionState.shadowRadius = mEffectiveShadowRadius;
Lloyd Piquec6687342019-03-07 21:34:57 -0800441
442 compositionState.contentDirty = contentDirty;
443 contentDirty = false;
444
445 compositionState.geomLayerBounds = mBounds;
446 compositionState.geomLayerTransform = getTransform();
447 compositionState.geomInverseLayerTransform = compositionState.geomLayerTransform.inverse();
448 compositionState.transparentRegionHint = getActiveTransparentRegion(drawingState);
449
450 compositionState.blendMode = static_cast<Hwc2::IComposerClient::BlendMode>(blendMode);
451 compositionState.alpha = alpha;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800452 compositionState.backgroundBlurRadius = drawingState.backgroundBlurRadius;
Lloyd Piquec6687342019-03-07 21:34:57 -0800453}
454
Lloyd Piquea83776c2019-01-29 18:42:32 -0800455void Layer::latchGeometry(compositionengine::LayerFECompositionState& compositionState) const {
456 const auto& drawingState{getDrawingState()};
Mathias Agopian13127d82013-03-05 17:47:11 -0800457
Lloyd Piquea83776c2019-01-29 18:42:32 -0800458 int type = drawingState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
459 int appId = drawingState.metadata.getInt32(METADATA_OWNER_UID, 0);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700460 sp<Layer> parent = mDrawingParent.promote();
Albert Chaulk2a589632017-05-04 16:59:44 -0400461 if (parent.get()) {
462 auto& parentState = parent->getDrawingState();
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800463 const int parentType = parentState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
464 const int parentAppId = parentState.metadata.getInt32(METADATA_OWNER_UID, 0);
Jiwen 'Steve' Cai736c74e2019-05-28 18:33:22 -0700465 if (parentType > 0 && parentAppId > 0) {
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800466 type = parentType;
467 appId = parentAppId;
rongliucfb187b2018-03-14 12:26:23 -0700468 }
Albert Chaulk2a589632017-05-04 16:59:44 -0400469 }
470
Lloyd Piquea83776c2019-01-29 18:42:32 -0800471 compositionState.geomBufferSize = getBufferSize(drawingState);
chaviw4244e032019-09-04 11:27:49 -0700472 compositionState.geomContentCrop = getBufferCrop();
Lloyd Piquea83776c2019-01-29 18:42:32 -0800473 compositionState.geomCrop = getCrop(drawingState);
chaviw4244e032019-09-04 11:27:49 -0700474 compositionState.geomBufferTransform = getBufferTransform();
Lloyd Piquea83776c2019-01-29 18:42:32 -0800475 compositionState.geomBufferUsesDisplayInverseTransform = getTransformToDisplayInverse();
Lloyd Piquea83776c2019-01-29 18:42:32 -0800476 compositionState.geomUsesSourceCrop = usesSourceCrop();
477 compositionState.isSecure = isSecure();
David Sodman15094112018-10-11 09:39:37 -0700478
Lloyd Piquea83776c2019-01-29 18:42:32 -0800479 compositionState.type = type;
480 compositionState.appId = appId;
481}
David Sodmanba340492018-08-05 21:51:33 -0700482
Lloyd Piquef5275482019-01-29 18:42:42 -0800483void Layer::latchPerFrameState(compositionengine::LayerFECompositionState& compositionState) const {
Lloyd Pique688abd42019-02-15 15:42:24 -0800484 const auto& drawingState{getDrawingState()};
Lloyd Piquef5275482019-01-29 18:42:42 -0800485 compositionState.forceClientComposition = false;
486
Lloyd Piquef5275482019-01-29 18:42:42 -0800487 compositionState.isColorspaceAgnostic = isColorSpaceAgnostic();
chaviw4244e032019-09-04 11:27:49 -0700488 compositionState.dataspace = getDataSpace();
Lloyd Piquef5275482019-01-29 18:42:42 -0800489 compositionState.colorTransform = getColorTransform();
490 compositionState.colorTransformIsIdentity = !hasColorTransform();
491 compositionState.surfaceDamage = surfaceDamageRegion;
Lloyd Pique688abd42019-02-15 15:42:24 -0800492 compositionState.hasProtectedContent = isProtected();
493
494 const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f;
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700495 const bool drawsShadows = mEffectiveShadowRadius != 0.f;
496
Lloyd Pique688abd42019-02-15 15:42:24 -0800497 compositionState.isOpaque =
498 isOpaque(drawingState) && !usesRoundedCorners && getAlpha() == 1.0_hf;
Lloyd Piquef5275482019-01-29 18:42:42 -0800499
500 // Force client composition for special cases known only to the front-end.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700501 if (isHdrY410() || usesRoundedCorners || drawsShadows) {
Lloyd Piquef5275482019-01-29 18:42:42 -0800502 compositionState.forceClientComposition = true;
503 }
504}
505
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800506void Layer::latchCursorCompositionState(
507 compositionengine::LayerFECompositionState& compositionState) const {
508 // This gives us only the "orientation" component of the transform
509 const State& drawingState{getDrawingState()};
510
511 // Apply the layer's transform, followed by the display's global transform
512 // Here we're guaranteed that the layer's transform preserves rects
513 Rect win = getCroppedBufferSize(drawingState);
514 // Subtract the transparent region and snap to the bounds
515 Rect bounds = reduce(win, getActiveTransparentRegion(drawingState));
516 Rect frame(getTransform().transform(bounds));
517
518 compositionState.cursorFrame = frame;
519}
520
Lloyd Piquef16688f2019-02-19 17:47:57 -0800521bool Layer::onPreComposition(nsecs_t) {
522 return false;
523}
524
Lloyd Piquea83776c2019-01-29 18:42:32 -0800525void Layer::latchCompositionState(compositionengine::LayerFECompositionState& compositionState,
Lloyd Piquec6687342019-03-07 21:34:57 -0800526 compositionengine::LayerFE::StateSubset subset) const {
527 using StateSubset = compositionengine::LayerFE::StateSubset;
Lloyd Piquef5275482019-01-29 18:42:42 -0800528
Lloyd Piquec6687342019-03-07 21:34:57 -0800529 switch (subset) {
530 case StateSubset::BasicGeometry:
531 latchBasicGeometry(compositionState);
532 break;
533
534 case StateSubset::GeometryAndContent:
535 latchBasicGeometry(compositionState);
536 latchGeometry(compositionState);
537 latchPerFrameState(compositionState);
538 break;
539
540 case StateSubset::Content:
541 latchPerFrameState(compositionState);
542 break;
543 }
Lloyd Piquea83776c2019-01-29 18:42:32 -0800544}
Mathias Agopian29a367b2011-07-12 14:51:45 -0700545
Lloyd Piquea83776c2019-01-29 18:42:32 -0800546const char* Layer::getDebugName() const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700547 return mName.c_str();
David Sodman4b7c4bc2017-11-17 12:13:59 -0800548}
549
Mathias Agopian13127d82013-03-05 17:47:11 -0800550// ---------------------------------------------------------------------------
551// drawing...
552// ---------------------------------------------------------------------------
553
Lloyd Piquef16688f2019-02-19 17:47:57 -0800554std::optional<renderengine::LayerSettings> Layer::prepareClientComposition(
555 compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
556 if (!getCompositionLayer()) {
557 return {};
558 }
Mathias Agopian13127d82013-03-05 17:47:11 -0800559
Vishnu Nair4351ad52019-02-11 14:13:02 -0800560 FloatRect bounds = getBounds();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000561 half alpha = getAlpha();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800562 renderengine::LayerSettings layerSettings;
563 layerSettings.geometry.boundaries = bounds;
564 if (targetSettings.useIdentityTransform) {
565 layerSettings.geometry.positionTransform = mat4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000566 } else {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800567 layerSettings.geometry.positionTransform = getTransform().asMatrix4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000568 }
569
570 if (hasColorTransform()) {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800571 layerSettings.colorTransform = getColorTransform();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000572 }
573
574 const auto roundedCornerState = getRoundedCornerState();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800575 layerSettings.geometry.roundedCornersRadius = roundedCornerState.radius;
576 layerSettings.geometry.roundedCornersCrop = roundedCornerState.cropRect;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000577
Lloyd Piquef16688f2019-02-19 17:47:57 -0800578 layerSettings.alpha = alpha;
chaviw4244e032019-09-04 11:27:49 -0700579 layerSettings.sourceDataspace = getDataSpace();
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800580 layerSettings.backgroundBlurRadius = getBackgroundBlurRadius();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800581 return layerSettings;
Mathias Agopian13127d82013-03-05 17:47:11 -0800582}
583
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800584std::optional<renderengine::LayerSettings> Layer::prepareShadowClientComposition(
585 const renderengine::LayerSettings& casterLayerSettings, const Rect& displayViewport,
586 ui::Dataspace outputDataspace) {
587 renderengine::ShadowSettings shadow = getShadowSettings(displayViewport);
588 if (shadow.length <= 0.f) {
589 return {};
590 }
591
592 const float casterAlpha = casterLayerSettings.alpha;
593 const bool casterIsOpaque = ((casterLayerSettings.source.buffer.buffer != nullptr) &&
594 casterLayerSettings.source.buffer.isOpaque);
595
596 renderengine::LayerSettings shadowLayer = casterLayerSettings;
597 shadowLayer.shadow = shadow;
Vishnu Naira483b4a2019-12-12 15:07:52 -0800598 shadowLayer.geometry.boundaries = mBounds; // ignore transparent region
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800599
600 // If the casting layer is translucent, we need to fill in the shadow underneath the layer.
601 // Otherwise the generated shadow will only be shown around the casting layer.
602 shadowLayer.shadow.casterIsTranslucent = !casterIsOpaque || (casterAlpha < 1.0f);
603 shadowLayer.shadow.ambientColor *= casterAlpha;
604 shadowLayer.shadow.spotColor *= casterAlpha;
605 shadowLayer.sourceDataspace = outputDataspace;
606 shadowLayer.source.buffer.buffer = nullptr;
607
608 if (shadowLayer.shadow.ambientColor.a <= 0.f && shadowLayer.shadow.spotColor.a <= 0.f) {
609 return {};
610 }
611
612 float casterCornerRadius = shadowLayer.geometry.roundedCornersRadius;
613 const FloatRect& cornerRadiusCropRect = casterLayerSettings.geometry.roundedCornersCrop;
614 const FloatRect& casterRect = shadowLayer.geometry.boundaries;
615
616 // crop used to set the corner radius may be larger than the content rect. Adjust the corner
617 // radius accordingly.
618 if (casterCornerRadius > 0.f) {
619 float cropRectOffset = std::max(std::abs(cornerRadiusCropRect.top - casterRect.top),
620 std::abs(cornerRadiusCropRect.left - casterRect.left));
621 if (cropRectOffset > casterCornerRadius) {
622 casterCornerRadius = 0;
623 } else {
624 casterCornerRadius -= cropRectOffset;
625 }
626 shadowLayer.geometry.roundedCornersRadius = casterCornerRadius;
627 }
628
629 return shadowLayer;
630}
631
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800632Hwc2::IComposerClient::Composition Layer::getCompositionType(
633 const sp<const DisplayDevice>& display) const {
634 const auto outputLayer = findOutputLayerForDisplay(display);
635 LOG_FATAL_IF(!outputLayer);
636 return outputLayer->getState().hwc ? (*outputLayer->getState().hwc).hwcCompositionType
637 : Hwc2::IComposerClient::Composition::CLIENT;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800638}
639
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800640bool Layer::getClearClientTarget(const sp<const DisplayDevice>& display) const {
641 const auto outputLayer = findOutputLayerForDisplay(display);
642 LOG_FATAL_IF(!outputLayer);
643 return outputLayer->getState().clearClientTarget;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800644}
Dan Stoza9e56aa02015-11-02 13:00:03 -0800645
Dan Stozacac35382016-01-27 12:21:06 -0800646bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
647 if (point->getFrameNumber() <= mCurrentFrameNumber) {
648 // Don't bother with a SyncPoint, since we've already latched the
649 // relevant frame
650 return false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700651 }
Robert Carr2e102c92018-10-23 12:11:15 -0700652 if (isRemovedFromCurrentState()) {
653 return false;
654 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700655
Dan Stozacac35382016-01-27 12:21:06 -0800656 Mutex::Autolock lock(mLocalSyncPointMutex);
657 mLocalSyncPoints.push_back(point);
658 return true;
Dan Stoza7dde5992015-05-22 09:51:44 -0700659}
660
Mathias Agopian13127d82013-03-05 17:47:11 -0800661// ----------------------------------------------------------------------------
662// local state
663// ----------------------------------------------------------------------------
664
David Sodman41fdfc92017-11-06 16:09:56 -0800665bool Layer::isSecure() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800666 const State& s(mDrawingState);
Dan Stoza23116082015-06-18 14:58:39 -0700667 return (s.flags & layer_state_t::eLayerSecure);
668}
669
Mathias Agopian13127d82013-03-05 17:47:11 -0800670// ----------------------------------------------------------------------------
671// transaction
672// ----------------------------------------------------------------------------
Ady Abraham83729882018-12-07 12:26:48 -0800673
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800674void Layer::pushPendingState() {
675 if (!mCurrentState.modified) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700676 return;
677 }
Alec Mourie60041e2019-06-14 18:59:51 -0700678 ATRACE_CALL();
Dan Stoza7dde5992015-05-22 09:51:44 -0700679
Dan Stoza7dde5992015-05-22 09:51:44 -0700680 // If this transaction is waiting on the receipt of a frame, generate a sync
681 // point and send it to the remote layer.
Robert Carr2e102c92018-10-23 12:11:15 -0700682 // We don't allow installing sync points after we are removed from the current state
683 // as we won't be able to signal our end.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800684 if (mCurrentState.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) {
685 sp<Layer> barrierLayer = mCurrentState.barrierLayer_legacy.promote();
Robert Carr0d480722017-01-10 16:42:54 -0800686 if (barrierLayer == nullptr) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700687 ALOGE("[%s] Unable to promote barrier Layer.", getDebugName());
Dan Stoza7dde5992015-05-22 09:51:44 -0700688 // If we can't promote the layer we are intended to wait on,
689 // then it is expired or otherwise invalid. Allow this transaction
690 // to be applied as per normal (no synchronization).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800691 mCurrentState.barrierLayer_legacy = nullptr;
Pablo Ceballos3bddd5b2015-11-19 14:39:14 -0800692 } else {
chaviw43cb3cb2019-05-31 15:23:41 -0700693 auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.frameNumber_legacy, this);
Robert Carr0d480722017-01-10 16:42:54 -0800694 if (barrierLayer->addSyncPoint(syncPoint)) {
Alec Mourie60041e2019-06-14 18:59:51 -0700695 std::stringstream ss;
696 ss << "Adding sync point " << mCurrentState.frameNumber_legacy;
697 ATRACE_NAME(ss.str().c_str());
Dan Stozacac35382016-01-27 12:21:06 -0800698 mRemoteSyncPoints.push_back(std::move(syncPoint));
699 } else {
700 // We already missed the frame we're supposed to synchronize
701 // on, so go ahead and apply the state update
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800702 mCurrentState.barrierLayer_legacy = nullptr;
Dan Stozacac35382016-01-27 12:21:06 -0800703 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700704 }
705
Dan Stoza7dde5992015-05-22 09:51:44 -0700706 // Wake us up to check if the frame has been received
707 setTransactionFlags(eTransactionNeeded);
Dan Stozaf5702ff2016-11-02 16:27:47 -0700708 mFlinger->setTransactionFlags(eTraversalNeeded);
Dan Stoza7dde5992015-05-22 09:51:44 -0700709 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800710 mPendingStates.push_back(mCurrentState);
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700711 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700712}
713
Pablo Ceballos05289c22016-04-14 15:49:55 -0700714void Layer::popPendingState(State* stateToCommit) {
Alec Mourie60041e2019-06-14 18:59:51 -0700715 ATRACE_CALL();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800716 *stateToCommit = mPendingStates[0];
Dan Stoza7dde5992015-05-22 09:51:44 -0700717
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800718 mPendingStates.removeAt(0);
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700719 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700720}
721
Pablo Ceballos05289c22016-04-14 15:49:55 -0700722bool Layer::applyPendingStates(State* stateToCommit) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700723 bool stateUpdateAvailable = false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800724 while (!mPendingStates.empty()) {
725 if (mPendingStates[0].barrierLayer_legacy != nullptr) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700726 if (mRemoteSyncPoints.empty()) {
727 // If we don't have a sync point for this, apply it anyway. It
728 // will be visually wrong, but it should keep us from getting
729 // into too much trouble.
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700730 ALOGE("[%s] No local sync point found", getDebugName());
Pablo Ceballos05289c22016-04-14 15:49:55 -0700731 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700732 stateUpdateAvailable = true;
733 continue;
734 }
735
Marissa Wallf58c14b2018-07-24 10:50:43 -0700736 if (mRemoteSyncPoints.front()->getFrameNumber() !=
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800737 mPendingStates[0].frameNumber_legacy) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700738 ALOGE("[%s] Unexpected sync point frame number found", getDebugName());
Dan Stozacac35382016-01-27 12:21:06 -0800739
740 // Signal our end of the sync point and then dispose of it
741 mRemoteSyncPoints.front()->setTransactionApplied();
742 mRemoteSyncPoints.pop_front();
743 continue;
744 }
745
Dan Stoza7dde5992015-05-22 09:51:44 -0700746 if (mRemoteSyncPoints.front()->frameIsAvailable()) {
Alec Mourie60041e2019-06-14 18:59:51 -0700747 ATRACE_NAME("frameIsAvailable");
Dan Stoza7dde5992015-05-22 09:51:44 -0700748 // Apply the state update
Pablo Ceballos05289c22016-04-14 15:49:55 -0700749 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700750 stateUpdateAvailable = true;
751
752 // Signal our end of the sync point and then dispose of it
753 mRemoteSyncPoints.front()->setTransactionApplied();
754 mRemoteSyncPoints.pop_front();
Dan Stoza792e5292016-02-11 11:43:58 -0800755 } else {
Alec Mourie60041e2019-06-14 18:59:51 -0700756 ATRACE_NAME("!frameIsAvailable");
Dan Stoza792e5292016-02-11 11:43:58 -0800757 break;
Dan Stoza7dde5992015-05-22 09:51:44 -0700758 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700759 } else {
Pablo Ceballos05289c22016-04-14 15:49:55 -0700760 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700761 stateUpdateAvailable = true;
762 }
763 }
764
765 // If we still have pending updates, wake SurfaceFlinger back up and point
766 // it at this layer so we can process them
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800767 if (!mPendingStates.empty()) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700768 setTransactionFlags(eTransactionNeeded);
769 mFlinger->setTransactionFlags(eTraversalNeeded);
770 }
771
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800772 mCurrentState.modified = false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700773 return stateUpdateAvailable;
774}
775
Marissa Wall61c58622018-07-18 10:12:20 -0700776uint32_t Layer::doTransactionResize(uint32_t flags, State* stateToCommit) {
Alec Mourib416efd2018-09-06 21:01:59 +0000777 const State& s(getDrawingState());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800778
Marissa Wall61c58622018-07-18 10:12:20 -0700779 const bool sizeChanged = (stateToCommit->requested_legacy.w != s.requested_legacy.w) ||
780 (stateToCommit->requested_legacy.h != s.requested_legacy.h);
Mathias Agopiana138f892010-05-21 17:24:35 -0700781
David Sodmaneb085e02017-10-05 18:49:04 -0700782 if (sizeChanged) {
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700783 // the size changed, we need to ask our client to request a new buffer
Steve Block9d453682011-12-20 16:23:08 +0000784 ALOGD_IF(DEBUG_RESIZE,
David Sodman41fdfc92017-11-06 16:09:56 -0800785 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
786 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
787 " requested={ wh={%4u,%4u} }}\n"
788 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
789 " requested={ wh={%4u,%4u} }}\n",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700790 this, getName().c_str(), getBufferTransform(), getEffectiveScalingMode(),
Marissa Wall61c58622018-07-18 10:12:20 -0700791 stateToCommit->active_legacy.w, stateToCommit->active_legacy.h,
792 stateToCommit->crop_legacy.left, stateToCommit->crop_legacy.top,
793 stateToCommit->crop_legacy.right, stateToCommit->crop_legacy.bottom,
794 stateToCommit->crop_legacy.getWidth(), stateToCommit->crop_legacy.getHeight(),
795 stateToCommit->requested_legacy.w, stateToCommit->requested_legacy.h,
Marissa Wallf58c14b2018-07-24 10:50:43 -0700796 s.active_legacy.w, s.active_legacy.h, s.crop_legacy.left, s.crop_legacy.top,
797 s.crop_legacy.right, s.crop_legacy.bottom, s.crop_legacy.getWidth(),
798 s.crop_legacy.getHeight(), s.requested_legacy.w, s.requested_legacy.h);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800799 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700800
Robert Carre392b552017-09-19 12:16:05 -0700801 // Don't let Layer::doTransaction update the drawing state
802 // if we have a pending resize, unless we are in fixed-size mode.
803 // the drawing state will be updated only once we receive a buffer
804 // with the correct size.
805 //
806 // In particular, we want to make sure the clip (which is part
807 // of the geometry state) is latched together with the size but is
808 // latched immediately when no resizing is involved.
809 //
810 // If a sideband stream is attached, however, we want to skip this
811 // optimization so that transactions aren't missed when a buffer
812 // never arrives
813 //
814 // In the case that we don't have a buffer we ignore other factors
815 // and avoid entering the resizePending state. At a high level the
816 // resizePending state is to avoid applying the state of the new buffer
817 // to the old buffer. However in the state where we don't have an old buffer
818 // there is no such concern but we may still be being used as a parent layer.
Marissa Wall61c58622018-07-18 10:12:20 -0700819 const bool resizePending =
820 ((stateToCommit->requested_legacy.w != stateToCommit->active_legacy.w) ||
821 (stateToCommit->requested_legacy.h != stateToCommit->active_legacy.h)) &&
chaviwd62d3062019-09-04 14:48:02 -0700822 (getBuffer() != nullptr);
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700823 if (!isFixedSize()) {
Lloyd Pique0b785d82018-12-04 17:25:27 -0800824 if (resizePending && mSidebandStream == nullptr) {
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700825 flags |= eDontUpdateGeometryState;
826 }
827 }
828
Robert Carr7bf247e2017-05-18 14:02:49 -0700829 // Here we apply various requested geometry states, depending on our
830 // latching configuration. See Layer.h for a detailed discussion of
831 // how geometry latching is controlled.
832 if (!(flags & eDontUpdateGeometryState)) {
Alec Mourib416efd2018-09-06 21:01:59 +0000833 State& editCurrentState(getCurrentState());
Robert Carr7bf247e2017-05-18 14:02:49 -0700834
Robert Carr7bf247e2017-05-18 14:02:49 -0700835 // There is an awkward asymmetry in the handling of the crop states in the position
836 // states, as can be seen below. Largely this arises from position and transform
837 // being stored in the same data structure while having different latching rules.
838 // b/38182305
839 //
Marissa Wall61c58622018-07-18 10:12:20 -0700840 // Careful that "stateToCommit" and editCurrentState may not begin as equivalent due to
Robert Carr7bf247e2017-05-18 14:02:49 -0700841 // applyPendingStates in the presence of deferred transactions.
chaviw214c89d2019-09-04 16:03:53 -0700842 editCurrentState.active_legacy = editCurrentState.requested_legacy;
843 stateToCommit->active_legacy = stateToCommit->requested_legacy;
Mathias Agopian13127d82013-03-05 17:47:11 -0800844 }
845
Marissa Wall61c58622018-07-18 10:12:20 -0700846 return flags;
847}
848
849uint32_t Layer::doTransaction(uint32_t flags) {
850 ATRACE_CALL();
851
chaviw5aedec92018-10-22 10:40:38 -0700852 if (mLayerDetached) {
Robert Carr321e83c2019-08-19 15:49:30 -0700853 // Ensure BLAST buffer callbacks are processed.
854 // detachChildren and mLayerDetached were implemented to avoid geometry updates
855 // to layers in the cases of animation. For BufferQueue layers buffers are still
856 // consumed as normal. This is useful as otherwise the client could get hung
857 // inevitably waiting on a buffer to return. We recreate this semantic for BufferQueue
858 // even though it is a little consistent. detachChildren is shortly slated for removal
859 // by the hierarchy mirroring work so we don't need to worry about it too much.
Valerie Hau7618b232020-01-09 16:03:08 -0800860 forceSendCallbacks();
Robert Carr321e83c2019-08-19 15:49:30 -0700861 mCurrentState.callbackHandles = {};
Robert Carr7f2ed8b2019-02-07 14:45:11 -0800862 return flags;
863 }
864
865 if (mChildrenChanged) {
866 flags |= eVisibleRegion;
867 mChildrenChanged = false;
chaviw5aedec92018-10-22 10:40:38 -0700868 }
869
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800870 pushPendingState();
Alec Mourib416efd2018-09-06 21:01:59 +0000871 State c = getCurrentState();
Marissa Wall61c58622018-07-18 10:12:20 -0700872 if (!applyPendingStates(&c)) {
Robert Carr7f2ed8b2019-02-07 14:45:11 -0800873 return flags;
Marissa Wall61c58622018-07-18 10:12:20 -0700874 }
875
876 flags = doTransactionResize(flags, &c);
877
Alec Mourib416efd2018-09-06 21:01:59 +0000878 const State& s(getDrawingState());
Marissa Wall61c58622018-07-18 10:12:20 -0700879
880 if (getActiveGeometry(c) != getActiveGeometry(s)) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800881 // invalidate and recompute the visible regions if needed
882 flags |= Layer::eVisibleRegion;
883 }
884
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700885 if (c.sequence != s.sequence) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800886 // invalidate and recompute the visible regions if needed
887 flags |= eVisibleRegion;
888 this->contentDirty = true;
889
890 // we may use linear filtering, if the matrix scales us
Marissa Wall61c58622018-07-18 10:12:20 -0700891 const uint8_t type = getActiveTransform(c).getType();
Peiyong Linefefaac2018-08-17 12:27:51 -0700892 mNeedsFiltering = (!getActiveTransform(c).preserveRects() || type >= ui::Transform::SCALE);
Mathias Agopian13127d82013-03-05 17:47:11 -0800893 }
894
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800895 if (mCurrentState.inputInfoChanged) {
Robert Carr720e5062018-07-30 17:45:14 -0700896 flags |= eInputInfoChanged;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800897 mCurrentState.inputInfoChanged = false;
Robert Carr720e5062018-07-30 17:45:14 -0700898 }
899
Mathias Agopian13127d82013-03-05 17:47:11 -0800900 // Commit the transaction
Pablo Ceballos05289c22016-04-14 15:49:55 -0700901 commitTransaction(c);
Vishnu Nair8406fd72019-07-30 11:29:31 -0700902 mPendingStatesSnapshot = mPendingStates;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800903 mCurrentState.callbackHandles = {};
Mathias Agopian13127d82013-03-05 17:47:11 -0800904 return flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800905}
906
Pablo Ceballos05289c22016-04-14 15:49:55 -0700907void Layer::commitTransaction(const State& stateToCommit) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800908 mDrawingState = stateToCommit;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700909}
910
Mathias Agopian13127d82013-03-05 17:47:11 -0800911uint32_t Layer::getTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800912 return mTransactionFlags.fetch_and(~flags) & flags;
Mathias Agopian13127d82013-03-05 17:47:11 -0800913}
914
915uint32_t Layer::setTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800916 return mTransactionFlags.fetch_or(flags);
Mathias Agopian13127d82013-03-05 17:47:11 -0800917}
918
chaviw214c89d2019-09-04 16:03:53 -0700919bool Layer::setPosition(float x, float y) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800920 if (mCurrentState.requested_legacy.transform.tx() == x &&
921 mCurrentState.requested_legacy.transform.ty() == y)
Mathias Agopian13127d82013-03-05 17:47:11 -0800922 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800923 mCurrentState.sequence++;
Robert Carr69663fb2016-03-27 19:59:19 -0700924
925 // We update the requested and active position simultaneously because
926 // we want to apply the position portion of the transform matrix immediately,
927 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800928 mCurrentState.requested_legacy.transform.set(x, y);
chaviw214c89d2019-09-04 16:03:53 -0700929 // Here we directly update the active state
930 // unlike other setters, because we store it within
931 // the transform, but use different latching rules.
932 // b/38182305
933 mCurrentState.active_legacy.transform.set(x, y);
Robert Carr69663fb2016-03-27 19:59:19 -0700934
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800935 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -0800936 setTransactionFlags(eTransactionNeeded);
937 return true;
938}
Robert Carr82364e32016-05-15 11:27:47 -0700939
Robert Carr1f0a16a2016-10-24 16:27:39 -0700940bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
941 ssize_t idx = mCurrentChildren.indexOf(childLayer);
942 if (idx < 0) {
943 return false;
944 }
945 if (childLayer->setLayer(z)) {
946 mCurrentChildren.removeAt(idx);
947 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -0800948 return true;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700949 }
Robert Carr503d2bd2017-12-04 15:49:47 -0800950 return false;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700951}
952
Robert Carr503c7042017-09-27 15:06:08 -0700953bool Layer::setChildRelativeLayer(const sp<Layer>& childLayer,
954 const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
955 ssize_t idx = mCurrentChildren.indexOf(childLayer);
956 if (idx < 0) {
957 return false;
958 }
959 if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) {
960 mCurrentChildren.removeAt(idx);
961 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -0800962 return true;
Robert Carr503c7042017-09-27 15:06:08 -0700963 }
Robert Carr503d2bd2017-12-04 15:49:47 -0800964 return false;
Robert Carr503c7042017-09-27 15:06:08 -0700965}
966
Robert Carrae060832016-11-28 10:51:00 -0800967bool Layer::setLayer(int32_t z) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800968 if (mCurrentState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
969 mCurrentState.sequence++;
970 mCurrentState.z = z;
971 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -0700972
973 // Discard all relative layering.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800974 if (mCurrentState.zOrderRelativeOf != nullptr) {
975 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
Robert Carrdb66e622017-04-10 16:55:57 -0700976 if (strongRelative != nullptr) {
977 strongRelative->removeZOrderRelative(this);
978 }
chaviw606e5cf2019-03-01 10:12:10 -0800979 setZOrderRelativeOf(nullptr);
Robert Carrdb66e622017-04-10 16:55:57 -0700980 }
Mathias Agopian13127d82013-03-05 17:47:11 -0800981 setTransactionFlags(eTransactionNeeded);
982 return true;
983}
Robert Carr1f0a16a2016-10-24 16:27:39 -0700984
Robert Carrdb66e622017-04-10 16:55:57 -0700985void Layer::removeZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800986 mCurrentState.zOrderRelatives.remove(relative);
987 mCurrentState.sequence++;
988 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -0700989 setTransactionFlags(eTransactionNeeded);
990}
991
992void Layer::addZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800993 mCurrentState.zOrderRelatives.add(relative);
994 mCurrentState.modified = true;
995 mCurrentState.sequence++;
Robert Carrdb66e622017-04-10 16:55:57 -0700996 setTransactionFlags(eTransactionNeeded);
997}
998
chaviw606e5cf2019-03-01 10:12:10 -0800999void Layer::setZOrderRelativeOf(const wp<Layer>& relativeOf) {
1000 mCurrentState.zOrderRelativeOf = relativeOf;
1001 mCurrentState.sequence++;
1002 mCurrentState.modified = true;
chaviwbdb8b802019-10-14 09:17:12 -07001003 mCurrentState.isRelativeOf = relativeOf != nullptr;
1004
chaviw606e5cf2019-03-01 10:12:10 -08001005 setTransactionFlags(eTransactionNeeded);
1006}
1007
Robert Carr503d2bd2017-12-04 15:49:47 -08001008bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
Robert Carrdb66e622017-04-10 16:55:57 -07001009 sp<Handle> handle = static_cast<Handle*>(relativeToHandle.get());
1010 if (handle == nullptr) {
1011 return false;
1012 }
1013 sp<Layer> relative = handle->owner.promote();
1014 if (relative == nullptr) {
1015 return false;
1016 }
1017
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001018 if (mCurrentState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) &&
1019 mCurrentState.zOrderRelativeOf == relative) {
Robert Carr503d2bd2017-12-04 15:49:47 -08001020 return false;
1021 }
1022
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001023 mCurrentState.sequence++;
1024 mCurrentState.modified = true;
1025 mCurrentState.z = relativeZ;
Robert Carrdb66e622017-04-10 16:55:57 -07001026
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001027 auto oldZOrderRelativeOf = mCurrentState.zOrderRelativeOf.promote();
chaviw9ab4bd12017-11-03 13:11:00 -07001028 if (oldZOrderRelativeOf != nullptr) {
1029 oldZOrderRelativeOf->removeZOrderRelative(this);
1030 }
chaviw606e5cf2019-03-01 10:12:10 -08001031 setZOrderRelativeOf(relative);
Robert Carrdb66e622017-04-10 16:55:57 -07001032 relative->addZOrderRelative(this);
1033
1034 setTransactionFlags(eTransactionNeeded);
1035
1036 return true;
1037}
1038
Mathias Agopian13127d82013-03-05 17:47:11 -08001039bool Layer::setSize(uint32_t w, uint32_t h) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001040 if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h)
Marissa Wallf58c14b2018-07-24 10:50:43 -07001041 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001042 mCurrentState.requested_legacy.w = w;
1043 mCurrentState.requested_legacy.h = h;
1044 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001045 setTransactionFlags(eTransactionNeeded);
Vishnu Naird01c4432018-08-13 10:38:47 -07001046
1047 // record the new size, from this point on, when the client request
1048 // a buffer, it'll get the new size.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001049 setDefaultBufferSize(mCurrentState.requested_legacy.w, mCurrentState.requested_legacy.h);
Mathias Agopian13127d82013-03-05 17:47:11 -08001050 return true;
1051}
Dan Stoza9e56aa02015-11-02 13:00:03 -08001052bool Layer::setAlpha(float alpha) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001053 if (mCurrentState.color.a == alpha) return false;
1054 mCurrentState.sequence++;
1055 mCurrentState.color.a = alpha;
1056 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001057 setTransactionFlags(eTransactionNeeded);
1058 return true;
1059}
chaviw13fdc492017-06-27 12:40:18 -07001060
Valerie Haudd0b7572019-01-29 14:59:27 -08001061bool Layer::setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace) {
1062 if (!mCurrentState.bgColorLayer && alpha == 0) {
chaviw13fdc492017-06-27 12:40:18 -07001063 return false;
Valerie Hauaa194562019-02-05 16:21:38 -08001064 }
1065 mCurrentState.sequence++;
1066 mCurrentState.modified = true;
1067 setTransactionFlags(eTransactionNeeded);
1068
1069 if (!mCurrentState.bgColorLayer && alpha != 0) {
Valerie Haudd0b7572019-01-29 14:59:27 -08001070 // create background color layer if one does not yet exist
1071 uint32_t flags = ISurfaceComposerClient::eFXSurfaceColor;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001072 std::string name = mName + "BackgroundColorLayer";
Lloyd Pique958be492019-03-28 15:34:59 -07001073 mCurrentState.bgColorLayer = mFlinger->getFactory().createColorLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001074 LayerCreationArgs(mFlinger.get(), nullptr, std::move(name), 0, 0, flags,
1075 LayerMetadata()));
chaviw13fdc492017-06-27 12:40:18 -07001076
Valerie Haudd0b7572019-01-29 14:59:27 -08001077 // add to child list
1078 addChild(mCurrentState.bgColorLayer);
1079 mFlinger->mLayersAdded = true;
1080 // set up SF to handle added color layer
1081 if (isRemovedFromCurrentState()) {
1082 mCurrentState.bgColorLayer->onRemovedFromCurrentState();
1083 }
1084 mFlinger->setTransactionFlags(eTransactionNeeded);
1085 } else if (mCurrentState.bgColorLayer && alpha == 0) {
1086 mCurrentState.bgColorLayer->reparent(nullptr);
1087 mCurrentState.bgColorLayer = nullptr;
1088 return true;
1089 }
1090
1091 mCurrentState.bgColorLayer->setColor(color);
1092 mCurrentState.bgColorLayer->setLayer(std::numeric_limits<int32_t>::min());
1093 mCurrentState.bgColorLayer->setAlpha(alpha);
1094 mCurrentState.bgColorLayer->setDataspace(dataspace);
1095
chaviw13fdc492017-06-27 12:40:18 -07001096 return true;
1097}
1098
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001099bool Layer::setCornerRadius(float cornerRadius) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001100 if (mCurrentState.cornerRadius == cornerRadius) return false;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001101
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001102 mCurrentState.sequence++;
1103 mCurrentState.cornerRadius = cornerRadius;
1104 mCurrentState.modified = true;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001105 setTransactionFlags(eTransactionNeeded);
1106 return true;
1107}
1108
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001109bool Layer::setBackgroundBlurRadius(int backgroundBlurRadius) {
1110 if (mCurrentState.backgroundBlurRadius == backgroundBlurRadius) return false;
1111
1112 mCurrentState.sequence++;
1113 mCurrentState.backgroundBlurRadius = backgroundBlurRadius;
1114 mCurrentState.modified = true;
1115 setTransactionFlags(eTransactionNeeded);
1116 return true;
1117}
1118
Robert Carrd4ae7f32018-06-07 16:10:57 -07001119bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix,
1120 bool allowNonRectPreservingTransforms) {
Peiyong Linefefaac2018-08-17 12:27:51 -07001121 ui::Transform t;
Robert Carrd4ae7f32018-06-07 16:10:57 -07001122 t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
1123
1124 if (!allowNonRectPreservingTransforms && !t.preserveRects()) {
1125 ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored");
1126 return false;
1127 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001128 mCurrentState.sequence++;
1129 mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
1130 matrix.dsdy);
1131 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001132 setTransactionFlags(eTransactionNeeded);
1133 return true;
1134}
Marissa Wall61c58622018-07-18 10:12:20 -07001135
Mathias Agopian13127d82013-03-05 17:47:11 -08001136bool Layer::setTransparentRegionHint(const Region& transparent) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001137 mCurrentState.requestedTransparentRegion_legacy = transparent;
1138 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001139 setTransactionFlags(eTransactionNeeded);
1140 return true;
1141}
Ana Krulecc84d09b2019-11-02 23:10:29 +01001142
Mathias Agopian13127d82013-03-05 17:47:11 -08001143bool Layer::setFlags(uint8_t flags, uint8_t mask) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001144 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
1145 if (mCurrentState.flags == newFlags) return false;
1146 mCurrentState.sequence++;
1147 mCurrentState.flags = newFlags;
1148 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001149 setTransactionFlags(eTransactionNeeded);
1150 return true;
1151}
Robert Carr99e27f02016-06-16 15:18:02 -07001152
chaviw214c89d2019-09-04 16:03:53 -07001153bool Layer::setCrop_legacy(const Rect& crop) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001154 if (mCurrentState.requestedCrop_legacy == crop) return false;
1155 mCurrentState.sequence++;
1156 mCurrentState.requestedCrop_legacy = crop;
chaviw214c89d2019-09-04 16:03:53 -07001157 mCurrentState.crop_legacy = crop;
Robert Carr7bf247e2017-05-18 14:02:49 -07001158
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001159 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001160 setTransactionFlags(eTransactionNeeded);
1161 return true;
1162}
Robert Carr8d5227b2017-03-16 15:41:03 -07001163
Robert Carrc3574f72016-03-24 12:19:32 -07001164bool Layer::setOverrideScalingMode(int32_t scalingMode) {
David Sodman41fdfc92017-11-06 16:09:56 -08001165 if (scalingMode == mOverrideScalingMode) return false;
Robert Carrc3574f72016-03-24 12:19:32 -07001166 mOverrideScalingMode = scalingMode;
Robert Carr82364e32016-05-15 11:27:47 -07001167 setTransactionFlags(eTransactionNeeded);
Robert Carrc3574f72016-03-24 12:19:32 -07001168 return true;
1169}
1170
Evan Roskyef876c92019-01-25 17:46:06 -08001171bool Layer::setMetadata(const LayerMetadata& data) {
1172 if (!mCurrentState.metadata.merge(data, true /* eraseEmpty */)) return false;
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001173 mCurrentState.sequence++;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001174 mCurrentState.modified = true;
David Sodman41fdfc92017-11-06 16:09:56 -08001175 setTransactionFlags(eTransactionNeeded);
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001176 return true;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001177}
1178
Mathias Agopian13127d82013-03-05 17:47:11 -08001179bool Layer::setLayerStack(uint32_t layerStack) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001180 if (mCurrentState.layerStack == layerStack) return false;
1181 mCurrentState.sequence++;
1182 mCurrentState.layerStack = layerStack;
1183 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001184 setTransactionFlags(eTransactionNeeded);
1185 return true;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001186}
1187
Peiyong Linc502cb72019-03-01 15:00:23 -08001188bool Layer::setColorSpaceAgnostic(const bool agnostic) {
1189 if (mCurrentState.colorSpaceAgnostic == agnostic) {
1190 return false;
1191 }
1192 mCurrentState.sequence++;
1193 mCurrentState.colorSpaceAgnostic = agnostic;
1194 mCurrentState.modified = true;
1195 setTransactionFlags(eTransactionNeeded);
1196 return true;
1197}
1198
Ana Krulecc84d09b2019-11-02 23:10:29 +01001199bool Layer::setFrameRateSelectionPriority(int32_t priority) {
1200 if (mCurrentState.frameRateSelectionPriority == priority) return false;
1201 mCurrentState.frameRateSelectionPriority = priority;
1202 mCurrentState.sequence++;
1203 mCurrentState.modified = true;
1204 setTransactionFlags(eTransactionNeeded);
1205 return true;
1206}
1207
1208int32_t Layer::getFrameRateSelectionPriority() const {
1209 // Check if layer has priority set.
1210 if (mDrawingState.frameRateSelectionPriority != PRIORITY_UNSET) {
1211 return mDrawingState.frameRateSelectionPriority;
1212 }
1213 // If not, search whether its parents have it set.
1214 sp<Layer> parent = getParent();
1215 if (parent != nullptr) {
1216 return parent->getFrameRateSelectionPriority();
1217 }
1218
1219 return Layer::PRIORITY_UNSET;
1220}
1221
Robert Carr1f0a16a2016-10-24 16:27:39 -07001222uint32_t Layer::getLayerStack() const {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001223 auto p = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001224 if (p == nullptr) {
1225 return getDrawingState().layerStack;
1226 }
1227 return p->getLayerStack();
1228}
1229
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001230bool Layer::setShadowRadius(float shadowRadius) {
1231 if (mCurrentState.shadowRadius == shadowRadius) {
1232 return false;
1233 }
1234
1235 mCurrentState.sequence++;
1236 mCurrentState.shadowRadius = shadowRadius;
1237 mCurrentState.modified = true;
1238 setTransactionFlags(eTransactionNeeded);
1239 return true;
1240}
1241
Steven Thomas3172e202020-01-06 19:25:30 -08001242bool Layer::setFrameRate(float frameRate) {
1243 if (mCurrentState.frameRate == frameRate) {
1244 return false;
1245 }
1246
1247 mCurrentState.sequence++;
1248 mCurrentState.frameRate = frameRate;
1249 mCurrentState.modified = true;
1250 setTransactionFlags(eTransactionNeeded);
1251 return true;
1252}
1253
1254float Layer::getFrameRate() const {
1255 return getDrawingState().frameRate;
1256}
1257
Marissa Wallf58c14b2018-07-24 10:50:43 -07001258void Layer::deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
Alec Mourie60041e2019-06-14 18:59:51 -07001259 ATRACE_CALL();
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001260 mCurrentState.barrierLayer_legacy = barrierLayer;
1261 mCurrentState.frameNumber_legacy = frameNumber;
Dan Stoza7dde5992015-05-22 09:51:44 -07001262 // We don't set eTransactionNeeded, because just receiving a deferral
1263 // request without any other state updates shouldn't actually induce a delay
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001264 mCurrentState.modified = true;
1265 pushPendingState();
1266 mCurrentState.barrierLayer_legacy = nullptr;
1267 mCurrentState.frameNumber_legacy = 0;
1268 mCurrentState.modified = false;
Robert Carr0d480722017-01-10 16:42:54 -08001269}
1270
Marissa Wallf58c14b2018-07-24 10:50:43 -07001271void Layer::deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
Robert Carr0d480722017-01-10 16:42:54 -08001272 sp<Handle> handle = static_cast<Handle*>(barrierHandle.get());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001273 deferTransactionUntil_legacy(handle->owner.promote(), frameNumber);
Dan Stoza7dde5992015-05-22 09:51:44 -07001274}
1275
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001276// ----------------------------------------------------------------------------
1277// pageflip handling...
1278// ----------------------------------------------------------------------------
1279
Robert Carr1f0a16a2016-10-24 16:27:39 -07001280bool Layer::isHiddenByPolicy() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001281 const State& s(mDrawingState);
Chia-I Wue41dbe62017-06-13 14:10:56 -07001282 const auto& parent = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001283 if (parent != nullptr && parent->isHiddenByPolicy()) {
1284 return true;
1285 }
Robert Carr1c5481e2019-07-01 14:42:27 -07001286 if (usingRelativeZ(LayerVector::StateSet::Drawing)) {
1287 auto zOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote();
1288 if (zOrderRelativeOf != nullptr) {
1289 if (zOrderRelativeOf->isHiddenByPolicy()) {
1290 return true;
1291 }
1292 }
1293 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07001294 return s.flags & layer_state_t::eLayerHidden;
1295}
1296
David Sodman41fdfc92017-11-06 16:09:56 -08001297uint32_t Layer::getEffectiveUsage(uint32_t usage) const {
Mathias Agopiana67932f2011-04-20 14:20:59 -07001298 // TODO: should we do something special if mSecure is set?
1299 if (mProtectedByApp) {
1300 // need a hardware-protected path to external video sink
1301 usage |= GraphicBuffer::USAGE_PROTECTED;
Jamie Gennis54cc83e2010-11-02 11:51:32 -07001302 }
Riley Andrews03414a12014-07-01 14:22:59 -07001303 if (mPotentialCursor) {
1304 usage |= GraphicBuffer::USAGE_CURSOR;
1305 }
Jamie Gennis3599bf22011-08-10 11:48:07 -07001306 usage |= GraphicBuffer::USAGE_HW_COMPOSER;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001307 return usage;
Mathias Agopianb5b7f262010-05-07 15:58:44 -07001308}
1309
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001310void Layer::updateTransformHint(const sp<const DisplayDevice>& display) const {
Mathias Agopiana4583642011-08-23 18:03:18 -07001311 uint32_t orientation = 0;
Vishnu Nair5eb3f062019-04-08 08:21:03 -07001312 // Disable setting transform hint if the debug flag is set.
1313 if (!mFlinger->mDebugDisableTransformHint) {
Mathias Agopian84300952012-11-21 16:02:13 -08001314 // The transform hint is used to improve performance, but we can
1315 // only have a single transform hint, it cannot
Mathias Agopian4fec8732012-06-29 14:12:52 -07001316 // apply to all displays.
Peiyong Linefefaac2018-08-17 12:27:51 -07001317 const ui::Transform& planeTransform = display->getTransform();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001318 orientation = planeTransform.getOrientation();
Peiyong Linefefaac2018-08-17 12:27:51 -07001319 if (orientation & ui::Transform::ROT_INVALID) {
Mathias Agopiana4583642011-08-23 18:03:18 -07001320 orientation = 0;
1321 }
1322 }
David Sodmaneb085e02017-10-05 18:49:04 -07001323 setTransformHint(orientation);
Mathias Agopiana4583642011-08-23 18:03:18 -07001324}
1325
Mathias Agopian13127d82013-03-05 17:47:11 -08001326// ----------------------------------------------------------------------------
1327// debugging
1328// ----------------------------------------------------------------------------
1329
Marissa Wall61c58622018-07-18 10:12:20 -07001330// TODO(marissaw): add new layer state info to layer debugging
Kalle Raitaa099a242017-01-11 11:17:29 -08001331LayerDebugInfo Layer::getLayerDebugInfo() const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001332 using namespace std::string_literals;
1333
Kalle Raitaa099a242017-01-11 11:17:29 -08001334 LayerDebugInfo info;
Alec Mourib416efd2018-09-06 21:01:59 +00001335 const State& ds = getDrawingState();
Kalle Raitaa099a242017-01-11 11:17:29 -08001336 info.mName = getName();
chaviw1acbec72017-07-27 15:28:26 -07001337 sp<Layer> parent = getParent();
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001338 info.mParentName = parent ? parent->getName() : "none"s;
chaviw8a01fa42019-08-19 12:39:31 -07001339 info.mType = getType();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001340 info.mTransparentRegion = ds.activeTransparentRegion_legacy;
Lloyd Piquea2468662019-03-07 21:31:06 -08001341
1342 info.mVisibleRegion = debugGetVisibleRegionOnDefaultDisplay();
Kalle Raitaa099a242017-01-11 11:17:29 -08001343 info.mSurfaceDamageRegion = surfaceDamageRegion;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001344 info.mLayerStack = getLayerStack();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001345 info.mX = ds.active_legacy.transform.tx();
1346 info.mY = ds.active_legacy.transform.ty();
Kalle Raitaa099a242017-01-11 11:17:29 -08001347 info.mZ = ds.z;
Marissa Wallf58c14b2018-07-24 10:50:43 -07001348 info.mWidth = ds.active_legacy.w;
1349 info.mHeight = ds.active_legacy.h;
1350 info.mCrop = ds.crop_legacy;
chaviw13fdc492017-06-27 12:40:18 -07001351 info.mColor = ds.color;
Kalle Raitaa099a242017-01-11 11:17:29 -08001352 info.mFlags = ds.flags;
1353 info.mPixelFormat = getPixelFormat();
chaviw4244e032019-09-04 11:27:49 -07001354 info.mDataSpace = static_cast<android_dataspace>(getDataSpace());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001355 info.mMatrix[0][0] = ds.active_legacy.transform[0][0];
1356 info.mMatrix[0][1] = ds.active_legacy.transform[0][1];
1357 info.mMatrix[1][0] = ds.active_legacy.transform[1][0];
1358 info.mMatrix[1][1] = ds.active_legacy.transform[1][1];
Kalle Raitaa099a242017-01-11 11:17:29 -08001359 {
chaviwd62d3062019-09-04 14:48:02 -07001360 sp<const GraphicBuffer> buffer = getBuffer();
David Sodman5b4cffc2017-11-23 13:20:29 -08001361 if (buffer != 0) {
1362 info.mActiveBufferWidth = buffer->getWidth();
1363 info.mActiveBufferHeight = buffer->getHeight();
1364 info.mActiveBufferStride = buffer->getStride();
1365 info.mActiveBufferFormat = buffer->format;
Kalle Raitaa099a242017-01-11 11:17:29 -08001366 } else {
1367 info.mActiveBufferWidth = 0;
1368 info.mActiveBufferHeight = 0;
1369 info.mActiveBufferStride = 0;
1370 info.mActiveBufferFormat = 0;
1371 }
Mathias Agopian13127d82013-03-05 17:47:11 -08001372 }
Kalle Raitaa099a242017-01-11 11:17:29 -08001373 info.mNumQueuedFrames = getQueuedFrameCount();
1374 info.mRefreshPending = isBufferLatched();
1375 info.mIsOpaque = isOpaque(ds);
1376 info.mContentDirty = contentDirty;
1377 return info;
Mathias Agopian13127d82013-03-05 17:47:11 -08001378}
Chia-I Wu83ce7c12017-10-19 15:18:55 -07001379
Yiwei Zhang5434a782018-12-05 18:06:32 -08001380void Layer::miniDumpHeader(std::string& result) {
Yichi Chen6ca35192018-05-29 12:20:43 +08001381 result.append("-------------------------------");
1382 result.append("-------------------------------");
1383 result.append("-----------------------------\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001384 result.append(" Layer name\n");
1385 result.append(" Z | ");
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001386 result.append(" Window Type | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001387 result.append(" Comp Type | ");
Yichi Chen6ca35192018-05-29 12:20:43 +08001388 result.append(" Transform | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001389 result.append(" Disp Frame (LTRB) | ");
1390 result.append(" Source Crop (LTRB)\n");
Yichi Chen6ca35192018-05-29 12:20:43 +08001391 result.append("-------------------------------");
1392 result.append("-------------------------------");
1393 result.append("-----------------------------\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001394}
1395
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001396void Layer::miniDump(std::string& result, const sp<DisplayDevice>& displayDevice) const {
1397 auto outputLayer = findOutputLayerForDisplay(displayDevice);
1398 if (!outputLayer) {
Dan Stozae22aec72016-08-01 13:20:59 -07001399 return;
1400 }
1401
Yiwei Zhang5434a782018-12-05 18:06:32 -08001402 std::string name;
Dan Stozae22aec72016-08-01 13:20:59 -07001403 if (mName.length() > 77) {
1404 std::string shortened;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001405 shortened.append(mName, 0, 36);
Dan Stozae22aec72016-08-01 13:20:59 -07001406 shortened.append("[...]");
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001407 shortened.append(mName, mName.length() - 36);
1408 name = std::move(shortened);
Dan Stozae22aec72016-08-01 13:20:59 -07001409 } else {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001410 name = mName;
Dan Stozae22aec72016-08-01 13:20:59 -07001411 }
1412
Yiwei Zhang5434a782018-12-05 18:06:32 -08001413 StringAppendF(&result, " %s\n", name.c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07001414
Alec Mourib416efd2018-09-06 21:01:59 +00001415 const State& layerState(getDrawingState());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001416 const auto& compositionState = outputLayer->getState();
1417
Chia-I Wu1e043612018-03-01 09:45:09 -08001418 if (layerState.zOrderRelativeOf != nullptr || mDrawingParent != nullptr) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001419 StringAppendF(&result, " rel %6d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001420 } else {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001421 StringAppendF(&result, " %10d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001422 }
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001423 StringAppendF(&result, " %10d | ", mWindowType);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001424 StringAppendF(&result, "%10s | ", toString(getCompositionType(displayDevice)).c_str());
1425 StringAppendF(&result, "%10s | ",
1426 toString(getCompositionLayer() ? compositionState.bufferTransform
1427 : static_cast<Hwc2::Transform>(0))
1428 .c_str());
1429 const Rect& frame = compositionState.displayFrame;
Yiwei Zhang5434a782018-12-05 18:06:32 -08001430 StringAppendF(&result, "%4d %4d %4d %4d | ", frame.left, frame.top, frame.right, frame.bottom);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001431 const FloatRect& crop = compositionState.sourceCrop;
Yiwei Zhang5434a782018-12-05 18:06:32 -08001432 StringAppendF(&result, "%6.1f %6.1f %6.1f %6.1f\n", crop.left, crop.top, crop.right,
1433 crop.bottom);
Dan Stozae22aec72016-08-01 13:20:59 -07001434
Yichi Chen6ca35192018-05-29 12:20:43 +08001435 result.append("- - - - - - - - - - - - - - - -");
1436 result.append("- - - - - - - - - - - - - - - -");
1437 result.append("- - - - - - - - - - - - - - -\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001438}
Dan Stozae22aec72016-08-01 13:20:59 -07001439
Yiwei Zhang5434a782018-12-05 18:06:32 -08001440void Layer::dumpFrameStats(std::string& result) const {
Svetoslavd85084b2014-03-20 10:28:31 -07001441 mFrameTracker.dumpStats(result);
Mathias Agopian13127d82013-03-05 17:47:11 -08001442}
1443
Svetoslavd85084b2014-03-20 10:28:31 -07001444void Layer::clearFrameStats() {
1445 mFrameTracker.clearStats();
Mathias Agopian13127d82013-03-05 17:47:11 -08001446}
1447
Jamie Gennis6547ff42013-07-16 20:12:42 -07001448void Layer::logFrameStats() {
1449 mFrameTracker.logAndResetStats(mName);
1450}
1451
Svetoslavd85084b2014-03-20 10:28:31 -07001452void Layer::getFrameStats(FrameStats* outStats) const {
1453 mFrameTracker.getStats(outStats);
1454}
1455
Yiwei Zhang5434a782018-12-05 18:06:32 -08001456void Layer::dumpFrameEvents(std::string& result) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001457 StringAppendF(&result, "- Layer %s (%s, %p)\n", getName().c_str(), getType(), this);
Brian Andersond6927fb2016-07-23 23:37:30 -07001458 Mutex::Autolock lock(mFrameEventHistoryMutex);
1459 mFrameEventHistory.checkFencesForCompletion();
1460 mFrameEventHistory.dump(result);
1461}
Pablo Ceballos40845df2016-01-25 17:41:15 -08001462
Vishnu Nair0f085c62019-08-30 08:49:12 -07001463void Layer::dumpCallingUidPid(std::string& result) const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001464 StringAppendF(&result, "Layer %s (%s) pid:%d uid:%d\n", getName().c_str(), getType(),
Vishnu Nair0f085c62019-08-30 08:49:12 -07001465 mCallingPid, mCallingUid);
1466}
1467
Brian Anderson5ea5e592016-12-01 16:54:33 -08001468void Layer::onDisconnect() {
1469 Mutex::Autolock lock(mFrameEventHistoryMutex);
1470 mFrameEventHistory.onDisconnect();
Yiwei Zhang1a88c402019-11-18 10:43:58 -08001471 const int32_t layerId = getSequence();
1472 mFlinger->mTimeStats->onDestroy(layerId);
1473 mFlinger->mFrameTracer->onDestroy(layerId);
Brian Anderson5ea5e592016-12-01 16:54:33 -08001474}
1475
Brian Anderson3890c392016-07-25 12:48:08 -07001476void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
David Sodman41fdfc92017-11-06 16:09:56 -08001477 FrameEventHistoryDelta* outDelta) {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001478 if (newTimestamps) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001479 mFlinger->mTimeStats->setPostTime(getSequence(), newTimestamps->frameNumber,
1480 getName().c_str(), newTimestamps->postedTime);
Yiwei Zhang487340f2019-11-18 17:42:12 -08001481 mFlinger->mTimeStats->setAcquireFence(getSequence(), newTimestamps->frameNumber,
1482 newTimestamps->acquireFence);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001483 }
1484
Brian Andersond6927fb2016-07-23 23:37:30 -07001485 Mutex::Autolock lock(mFrameEventHistoryMutex);
1486 if (newTimestamps) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001487 // If there are any unsignaled fences in the aquire timeline at this
1488 // point, the previously queued frame hasn't been latched yet. Go ahead
1489 // and try to get the signal time here so the syscall is taken out of
1490 // the main thread's critical path.
1491 mAcquireTimeline.updateSignalTimes();
1492 // Push the new fence after updating since it's likely still pending.
Brian Anderson3d4039d2016-09-23 16:31:30 -07001493 mAcquireTimeline.push(newTimestamps->acquireFence);
Brian Andersond6927fb2016-07-23 23:37:30 -07001494 mFrameEventHistory.addQueue(*newTimestamps);
1495 }
1496
Brian Anderson3890c392016-07-25 12:48:08 -07001497 if (outDelta) {
1498 mFrameEventHistory.getAndResetDelta(outDelta);
Brian Andersond6927fb2016-07-23 23:37:30 -07001499 }
Pablo Ceballos40845df2016-01-25 17:41:15 -08001500}
Dan Stozae77c7662016-05-13 11:37:28 -07001501
Chia-I Wu98f1c102017-05-30 14:54:08 -07001502size_t Layer::getChildrenCount() const {
1503 size_t count = 0;
1504 for (const sp<Layer>& child : mCurrentChildren) {
1505 count += 1 + child->getChildrenCount();
1506 }
1507 return count;
1508}
1509
Robert Carr1f0a16a2016-10-24 16:27:39 -07001510void Layer::addChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001511 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001512 setTransactionFlags(eTransactionNeeded);
Robert Carr1323c952019-01-28 18:13:27 -08001513
Robert Carr1f0a16a2016-10-24 16:27:39 -07001514 mCurrentChildren.add(layer);
1515 layer->setParent(this);
1516}
1517
1518ssize_t Layer::removeChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001519 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001520 setTransactionFlags(eTransactionNeeded);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001521
Robert Carr1323c952019-01-28 18:13:27 -08001522 layer->setParent(nullptr);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001523 return mCurrentChildren.remove(layer);
1524}
1525
Robert Carr1db73f62016-12-21 12:58:51 -08001526bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) {
1527 sp<Handle> handle = nullptr;
1528 sp<Layer> newParent = nullptr;
1529 if (newParentHandle == nullptr) {
1530 return false;
1531 }
1532 handle = static_cast<Handle*>(newParentHandle.get());
1533 newParent = handle->owner.promote();
1534 if (newParent == nullptr) {
1535 ALOGE("Unable to promote Layer handle");
1536 return false;
1537 }
1538
chaviw5aedec92018-10-22 10:40:38 -07001539 if (attachChildren()) {
1540 setTransactionFlags(eTransactionNeeded);
1541 }
Robert Carr1db73f62016-12-21 12:58:51 -08001542 for (const sp<Layer>& child : mCurrentChildren) {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001543 newParent->addChild(child);
Robert Carr1db73f62016-12-21 12:58:51 -08001544 }
1545 mCurrentChildren.clear();
1546
1547 return true;
1548}
1549
Robert Carr15eae092018-03-23 13:43:53 -07001550void Layer::setChildrenDrawingParent(const sp<Layer>& newParent) {
Robert Carr578038f2018-03-09 12:25:24 -08001551 for (const sp<Layer>& child : mDrawingChildren) {
1552 child->mDrawingParent = newParent;
Vishnu Nairc652ff82019-03-15 12:48:54 -07001553 child->computeBounds(newParent->mBounds,
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001554 newParent->getTransformWithScale(newParent->getBufferScaleTransform()),
1555 newParent->mEffectiveShadowRadius);
Robert Carr578038f2018-03-09 12:25:24 -08001556 }
1557}
1558
chaviwf1961f72017-09-18 16:41:07 -07001559bool Layer::reparent(const sp<IBinder>& newParentHandle) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001560 bool callSetTransactionFlags = false;
chaviw06178942017-07-27 10:25:59 -07001561
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001562 // While layers are detached, we allow most operations
1563 // and simply halt performing the actual transaction. However
1564 // for reparent != null we would enter the mRemovedFromCurrentState
1565 // state, regardless of whether doTransaction was called, and
1566 // so we need to prevent the update here.
1567 if (mLayerDetached && newParentHandle == nullptr) {
chaviw06178942017-07-27 10:25:59 -07001568 return false;
1569 }
1570
Robert Carr54cf5b12019-01-25 14:02:28 -08001571 sp<Layer> newParent;
1572 if (newParentHandle != nullptr) {
1573 auto handle = static_cast<Handle*>(newParentHandle.get());
1574 newParent = handle->owner.promote();
1575 if (newParent == nullptr) {
1576 ALOGE("Unable to promote Layer handle");
1577 return false;
1578 }
1579 if (newParent == this) {
1580 ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str());
1581 return false;
1582 }
1583 }
1584
chaviwf1961f72017-09-18 16:41:07 -07001585 sp<Layer> parent = getParent();
1586 if (parent != nullptr) {
1587 parent->removeChild(this);
chaviw06178942017-07-27 10:25:59 -07001588 }
1589
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001590 if (newParentHandle != nullptr) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001591 newParent->addChild(this);
1592 if (!newParent->isRemovedFromCurrentState()) {
1593 addToCurrentState();
1594 } else {
1595 onRemovedFromCurrentState();
1596 }
1597
1598 if (mLayerDetached) {
1599 mLayerDetached = false;
1600 callSetTransactionFlags = true;
1601 }
1602 } else {
1603 onRemovedFromCurrentState();
chaviw61626f22018-11-15 16:26:27 -08001604 }
1605
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001606 if (callSetTransactionFlags || attachChildren()) {
chaviw5aedec92018-10-22 10:40:38 -07001607 setTransactionFlags(eTransactionNeeded);
1608 }
chaviw06178942017-07-27 10:25:59 -07001609 return true;
1610}
1611
Robert Carr9524cb32017-02-13 11:32:32 -08001612bool Layer::detachChildren() {
Robert Carr7f619b22017-11-06 12:56:35 -08001613 for (const sp<Layer>& child : mCurrentChildren) {
chaviw161410b02017-07-27 10:46:08 -07001614 sp<Client> parentClient = mClientRef.promote();
Robert Carr9524cb32017-02-13 11:32:32 -08001615 sp<Client> client(child->mClientRef.promote());
chaviw161410b02017-07-27 10:46:08 -07001616 if (client != nullptr && parentClient != client) {
chaviw5aedec92018-10-22 10:40:38 -07001617 child->mLayerDetached = true;
Robert Carr7f619b22017-11-06 12:56:35 -08001618 child->detachChildren();
chaviw43cb3cb2019-05-31 15:23:41 -07001619 child->removeRemoteSyncPoints();
Robert Carr9524cb32017-02-13 11:32:32 -08001620 }
Robert Carr7f619b22017-11-06 12:56:35 -08001621 }
Robert Carr9524cb32017-02-13 11:32:32 -08001622
1623 return true;
1624}
1625
chaviw5aedec92018-10-22 10:40:38 -07001626bool Layer::attachChildren() {
1627 bool changed = false;
1628 for (const sp<Layer>& child : mCurrentChildren) {
1629 sp<Client> parentClient = mClientRef.promote();
1630 sp<Client> client(child->mClientRef.promote());
1631 if (client != nullptr && parentClient != client) {
1632 if (child->mLayerDetached) {
1633 child->mLayerDetached = false;
1634 changed = true;
1635 }
1636 changed |= child->attachChildren();
1637 }
1638 }
1639
1640 return changed;
1641}
1642
Peiyong Lind3788632018-09-18 16:01:31 -07001643bool Layer::setColorTransform(const mat4& matrix) {
Peiyong Lin747321c2018-10-01 10:03:11 -07001644 static const mat4 identityMatrix = mat4();
1645
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001646 if (mCurrentState.colorTransform == matrix) {
Peiyong Lind3788632018-09-18 16:01:31 -07001647 return false;
1648 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001649 ++mCurrentState.sequence;
1650 mCurrentState.colorTransform = matrix;
1651 mCurrentState.hasColorTransform = matrix != identityMatrix;
1652 mCurrentState.modified = true;
Peiyong Lind3788632018-09-18 16:01:31 -07001653 setTransactionFlags(eTransactionNeeded);
1654 return true;
1655}
1656
chaviwf66724d2018-11-28 16:35:21 -08001657mat4 Layer::getColorTransform() const {
1658 mat4 colorTransform = mat4(getDrawingState().colorTransform);
1659 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
1660 colorTransform = parent->getColorTransform() * colorTransform;
1661 }
1662 return colorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07001663}
1664
1665bool Layer::hasColorTransform() const {
chaviwf66724d2018-11-28 16:35:21 -08001666 bool hasColorTransform = getDrawingState().hasColorTransform;
1667 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
1668 hasColorTransform = hasColorTransform || parent->hasColorTransform();
1669 }
1670 return hasColorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07001671}
1672
Chia-I Wu11481472018-05-04 10:43:19 -07001673bool Layer::isLegacyDataSpace() const {
1674 // return true when no higher bits are set
chaviw4244e032019-09-04 11:27:49 -07001675 return !(getDataSpace() &
1676 (ui::Dataspace::STANDARD_MASK | ui::Dataspace::TRANSFER_MASK |
1677 ui::Dataspace::RANGE_MASK));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08001678}
1679
Robert Carr1f0a16a2016-10-24 16:27:39 -07001680void Layer::setParent(const sp<Layer>& layer) {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001681 mCurrentParent = layer;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001682}
1683
chaviw301b1d82019-11-06 13:15:09 -08001684int32_t Layer::getZ(LayerVector::StateSet stateSet) const {
1685 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1686 const State& state = useDrawing ? mDrawingState : mCurrentState;
1687 return state.z;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001688}
1689
Robert Carr1c5481e2019-07-01 14:42:27 -07001690bool Layer::usingRelativeZ(LayerVector::StateSet stateSet) const {
Robert Carr29abff82017-12-04 13:51:20 -08001691 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001692 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviwe5ac40f2019-09-24 16:36:55 -07001693 return state.isRelativeOf;
Robert Carr29abff82017-12-04 13:51:20 -08001694}
1695
David Sodman41fdfc92017-11-06 16:09:56 -08001696__attribute__((no_sanitize("unsigned-integer-overflow"))) LayerVector Layer::makeTraversalList(
Robert Carr29abff82017-12-04 13:51:20 -08001697 LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers) {
Dan Stoza412903f2017-04-27 13:42:17 -07001698 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
1699 "makeTraversalList received invalid stateSet");
1700 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1701 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001702 const State& state = useDrawing ? mDrawingState : mCurrentState;
Dan Stoza412903f2017-04-27 13:42:17 -07001703
Robert Carr29abff82017-12-04 13:51:20 -08001704 if (state.zOrderRelatives.size() == 0) {
1705 *outSkipRelativeZUsers = true;
1706 return children;
1707 }
1708
chaviwfd462612018-05-31 16:11:27 -07001709 LayerVector traverse(stateSet);
Dan Stoza412903f2017-04-27 13:42:17 -07001710 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
Robert Carrdb66e622017-04-10 16:55:57 -07001711 sp<Layer> strongRelative = weakRelative.promote();
1712 if (strongRelative != nullptr) {
1713 traverse.add(strongRelative);
Robert Carrdb66e622017-04-10 16:55:57 -07001714 }
1715 }
1716
Dan Stoza412903f2017-04-27 13:42:17 -07001717 for (const sp<Layer>& child : children) {
chaviwe5ac40f2019-09-24 16:36:55 -07001718 if (child->usingRelativeZ(stateSet)) {
Robert Carr503c7042017-09-27 15:06:08 -07001719 continue;
1720 }
Robert Carrdb66e622017-04-10 16:55:57 -07001721 traverse.add(child);
1722 }
1723
1724 return traverse;
1725}
1726
Robert Carr1f0a16a2016-10-24 16:27:39 -07001727/**
Robert Carrdb66e622017-04-10 16:55:57 -07001728 * Negatively signed relatives are before 'this' in Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07001729 */
Dan Stoza412903f2017-04-27 13:42:17 -07001730void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08001731 // In the case we have other layers who are using a relative Z to us, makeTraversalList will
1732 // produce a new list for traversing, including our relatives, and not including our children
1733 // who are relatives of another surface. In the case that there are no relative Z,
1734 // makeTraversalList returns our children directly to avoid significant overhead.
1735 // However in this case we need to take the responsibility for filtering children which
1736 // are relatives of another surface here.
1737 bool skipRelativeZUsers = false;
1738 const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07001739
Robert Carr1f0a16a2016-10-24 16:27:39 -07001740 size_t i = 0;
Robert Carrdb66e622017-04-10 16:55:57 -07001741 for (; i < list.size(); i++) {
1742 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001743 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1744 continue;
1745 }
1746
chaviw301b1d82019-11-06 13:15:09 -08001747 if (relative->getZ(stateSet) >= 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001748 break;
Robert Carrdb66e622017-04-10 16:55:57 -07001749 }
Dan Stoza412903f2017-04-27 13:42:17 -07001750 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001751 }
Robert Carr29abff82017-12-04 13:51:20 -08001752
Dan Stoza412903f2017-04-27 13:42:17 -07001753 visitor(this);
Robert Carrdb66e622017-04-10 16:55:57 -07001754 for (; i < list.size(); i++) {
1755 const auto& relative = list[i];
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001756
Robert Carr29abff82017-12-04 13:51:20 -08001757 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1758 continue;
1759 }
Dan Stoza412903f2017-04-27 13:42:17 -07001760 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001761 }
1762}
1763
1764/**
Robert Carrdb66e622017-04-10 16:55:57 -07001765 * Positively signed relatives are before 'this' in reverse Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07001766 */
Dan Stoza412903f2017-04-27 13:42:17 -07001767void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet,
1768 const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08001769 // See traverseInZOrder for documentation.
1770 bool skipRelativeZUsers = false;
1771 LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07001772
Robert Carr1f0a16a2016-10-24 16:27:39 -07001773 int32_t i = 0;
Joel Galensonbf324992017-11-06 11:04:12 -08001774 for (i = int32_t(list.size()) - 1; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07001775 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001776
1777 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1778 continue;
1779 }
1780
chaviw301b1d82019-11-06 13:15:09 -08001781 if (relative->getZ(stateSet) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001782 break;
1783 }
Dan Stoza412903f2017-04-27 13:42:17 -07001784 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001785 }
Dan Stoza412903f2017-04-27 13:42:17 -07001786 visitor(this);
David Sodman41fdfc92017-11-06 16:09:56 -08001787 for (; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07001788 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001789
1790 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1791 continue;
1792 }
1793
Dan Stoza412903f2017-04-27 13:42:17 -07001794 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001795 }
1796}
1797
Edgar Arriaga844fa672020-01-16 14:21:42 -08001798void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) {
1799 visitor(this);
1800 const LayerVector& children =
1801 state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren;
1802 for (const sp<Layer>& child : children) {
1803 child->traverse(state, visitor);
1804 }
1805}
1806
chaviw4b129c22018-04-09 16:19:43 -07001807LayerVector Layer::makeChildrenTraversalList(LayerVector::StateSet stateSet,
1808 const std::vector<Layer*>& layersInTree) {
1809 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
1810 "makeTraversalList received invalid stateSet");
chaviwa76b2712017-09-20 12:02:26 -07001811 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1812 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001813 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07001814
chaviwfd462612018-05-31 16:11:27 -07001815 LayerVector traverse(stateSet);
chaviw4b129c22018-04-09 16:19:43 -07001816 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
1817 sp<Layer> strongRelative = weakRelative.promote();
1818 // Only add relative layers that are also descendents of the top most parent of the tree.
1819 // If a relative layer is not a descendent, then it should be ignored.
1820 if (std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
1821 traverse.add(strongRelative);
1822 }
1823 }
1824
1825 for (const sp<Layer>& child : children) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001826 const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07001827 // If a layer has a relativeOf layer, only ignore if the layer it's relative to is a
1828 // descendent of the top most parent of the tree. If it's not a descendent, then just add
1829 // the child here since it won't be added later as a relative.
1830 if (std::binary_search(layersInTree.begin(), layersInTree.end(),
1831 childState.zOrderRelativeOf.promote().get())) {
1832 continue;
1833 }
1834 traverse.add(child);
1835 }
1836
1837 return traverse;
1838}
1839
1840void Layer::traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
1841 LayerVector::StateSet stateSet,
1842 const LayerVector::Visitor& visitor) {
1843 const LayerVector list = makeChildrenTraversalList(stateSet, layersInTree);
chaviwa76b2712017-09-20 12:02:26 -07001844
1845 size_t i = 0;
chaviw4b129c22018-04-09 16:19:43 -07001846 for (; i < list.size(); i++) {
1847 const auto& relative = list[i];
chaviw301b1d82019-11-06 13:15:09 -08001848 if (relative->getZ(stateSet) >= 0) {
chaviwa76b2712017-09-20 12:02:26 -07001849 break;
1850 }
chaviw4b129c22018-04-09 16:19:43 -07001851 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07001852 }
chaviw4b129c22018-04-09 16:19:43 -07001853
chaviwa76b2712017-09-20 12:02:26 -07001854 visitor(this);
chaviw4b129c22018-04-09 16:19:43 -07001855 for (; i < list.size(); i++) {
1856 const auto& relative = list[i];
1857 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07001858 }
1859}
1860
chaviw4b129c22018-04-09 16:19:43 -07001861std::vector<Layer*> Layer::getLayersInTree(LayerVector::StateSet stateSet) {
1862 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1863 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
1864
1865 std::vector<Layer*> layersInTree = {this};
1866 for (size_t i = 0; i < children.size(); i++) {
1867 const auto& child = children[i];
1868 std::vector<Layer*> childLayers = child->getLayersInTree(stateSet);
1869 layersInTree.insert(layersInTree.end(), childLayers.cbegin(), childLayers.cend());
1870 }
1871
1872 return layersInTree;
1873}
1874
1875void Layer::traverseChildrenInZOrder(LayerVector::StateSet stateSet,
1876 const LayerVector::Visitor& visitor) {
1877 std::vector<Layer*> layersInTree = getLayersInTree(stateSet);
1878 std::sort(layersInTree.begin(), layersInTree.end());
1879 traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
1880}
1881
Peiyong Linefefaac2018-08-17 12:27:51 -07001882ui::Transform Layer::getTransform() const {
Vishnu Nairf0c28512019-02-08 12:40:28 -08001883 return mEffectiveTransform;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001884}
1885
chaviw13fdc492017-06-27 12:40:18 -07001886half Layer::getAlpha() const {
Ady Abraham83729882018-12-07 12:26:48 -08001887 const auto& p = mDrawingParent.promote();
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001888
chaviw13fdc492017-06-27 12:40:18 -07001889 half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf;
1890 return parentAlpha * getDrawingState().color.a;
Robert Carr6452f122017-03-21 10:41:29 -07001891}
Robert Carr6452f122017-03-21 10:41:29 -07001892
chaviw13fdc492017-06-27 12:40:18 -07001893half4 Layer::getColor() const {
1894 const half4 color(getDrawingState().color);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001895 return half4(color.r, color.g, color.b, getAlpha());
Robert Carr6452f122017-03-21 10:41:29 -07001896}
Robert Carr6452f122017-03-21 10:41:29 -07001897
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001898int32_t Layer::getBackgroundBlurRadius() const {
1899 return getDrawingState().backgroundBlurRadius;
1900}
1901
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001902Layer::RoundedCornerState Layer::getRoundedCornerState() const {
1903 const auto& p = mDrawingParent.promote();
1904 if (p != nullptr) {
Peiyong Lin27016a92019-03-29 17:36:08 +00001905 RoundedCornerState parentState = p->getRoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001906 if (parentState.radius > 0) {
1907 ui::Transform t = getActiveTransform(getDrawingState());
1908 t = t.inverse();
1909 parentState.cropRect = t.transform(parentState.cropRect);
1910 // The rounded corners shader only accepts 1 corner radius for performance reasons,
1911 // but a transform matrix can define horizontal and vertical scales.
1912 // Let's take the average between both of them and pass into the shader, practically we
1913 // never do this type of transformation on windows anyway.
1914 parentState.radius *= (t[0][0] + t[1][1]) / 2.0f;
1915 return parentState;
1916 }
1917 }
1918 const float radius = getDrawingState().cornerRadius;
Peiyong Linb9ff23e2019-04-08 11:04:59 -07001919 return radius > 0 && getCrop(getDrawingState()).isValid()
1920 ? RoundedCornerState(getCrop(getDrawingState()).toFloatRect(), radius)
1921 : RoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001922}
1923
Vishnu Nair08f6eae2019-11-26 14:01:39 -08001924renderengine::ShadowSettings Layer::getShadowSettings(const Rect& viewport) const {
1925 renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings;
1926
1927 // Shift the spot light x-position to the middle of the display and then
1928 // offset it by casting layer's screen pos.
1929 state.lightPos.x = (viewport.width() / 2.f) - mScreenBounds.left;
1930 state.lightPos.y -= mScreenBounds.top;
1931
1932 state.length = mEffectiveShadowRadius;
1933 return state;
1934}
1935
Robert Carr1f0a16a2016-10-24 16:27:39 -07001936void Layer::commitChildList() {
1937 for (size_t i = 0; i < mCurrentChildren.size(); i++) {
1938 const auto& child = mCurrentChildren[i];
1939 child->commitChildList();
1940 }
1941 mDrawingChildren = mCurrentChildren;
Chia-I Wue41dbe62017-06-13 14:10:56 -07001942 mDrawingParent = mCurrentParent;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001943}
1944
Vishnu Nair6fabeec2019-03-12 13:42:49 -07001945static wp<Layer> extractLayerFromBinder(const wp<IBinder>& weakBinderHandle) {
1946 if (weakBinderHandle == nullptr) {
1947 return nullptr;
1948 }
1949 sp<IBinder> binderHandle = weakBinderHandle.promote();
1950 if (binderHandle == nullptr) {
1951 return nullptr;
1952 }
1953 sp<Layer::Handle> handle = static_cast<Layer::Handle*>(binderHandle.get());
1954 if (handle == nullptr) {
1955 return nullptr;
1956 }
1957 return handle->owner;
1958}
1959
Robert Carr720e5062018-07-30 17:45:14 -07001960void Layer::setInputInfo(const InputWindowInfo& info) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001961 mCurrentState.inputInfo = info;
Vishnu Nair6fabeec2019-03-12 13:42:49 -07001962 mCurrentState.touchableRegionCrop = extractLayerFromBinder(info.touchableRegionCropHandle);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001963 mCurrentState.modified = true;
1964 mCurrentState.inputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07001965 setTransactionFlags(eTransactionNeeded);
1966}
1967
chaviw6d89e2d2020-01-14 14:42:01 -08001968LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags) const {
chaviw08f3cb22020-01-13 13:17:21 -08001969 LayerProto* layerProto = layersProto.add_layers();
1970 writeToProtoDrawingState(layerProto, traceFlags);
1971 writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);
1972
1973 for (const sp<Layer>& layer : mDrawingChildren) {
1974 layer->writeToProto(layersProto, traceFlags);
1975 }
chaviw6d89e2d2020-01-14 14:42:01 -08001976
1977 return layerProto;
chaviw08f3cb22020-01-13 13:17:21 -08001978}
1979
Vishnu Nair8406fd72019-07-30 11:29:31 -07001980void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags) const {
1981 ui::Transform transform = getTransform();
1982
1983 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
1984 for (const auto& pendingState : mPendingStatesSnapshot) {
1985 auto barrierLayer = pendingState.barrierLayer_legacy.promote();
1986 if (barrierLayer != nullptr) {
1987 BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();
1988 barrierLayerProto->set_id(barrierLayer->sequence);
1989 barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);
1990 }
1991 }
1992
chaviwd62d3062019-09-04 14:48:02 -07001993 auto buffer = getBuffer();
Vishnu Nair8406fd72019-07-30 11:29:31 -07001994 if (buffer != nullptr) {
1995 LayerProtoHelper::writeToProto(buffer,
1996 [&]() { return layerInfo->mutable_active_buffer(); });
chaviw4244e032019-09-04 11:27:49 -07001997 LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()),
Vishnu Nair8406fd72019-07-30 11:29:31 -07001998 layerInfo->mutable_buffer_transform());
1999 }
2000 layerInfo->set_invalidate(contentDirty);
2001 layerInfo->set_is_protected(isProtected());
chaviw4244e032019-09-04 11:27:49 -07002002 layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(getDataSpace())));
Vishnu Nair8406fd72019-07-30 11:29:31 -07002003 layerInfo->set_queued_frames(getQueuedFrameCount());
2004 layerInfo->set_refresh_pending(isBufferLatched());
2005 layerInfo->set_curr_frame(mCurrentFrameNumber);
2006 layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());
2007
2008 layerInfo->set_corner_radius(getRoundedCornerState().radius);
2009 LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());
2010 LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),
2011 [&]() { return layerInfo->mutable_position(); });
2012 LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
Lloyd Piquea2468662019-03-07 21:31:06 -08002013 LayerProtoHelper::writeToProto(debugGetVisibleRegionOnDefaultDisplay(),
Vishnu Nair8406fd72019-07-30 11:29:31 -07002014 [&]() { return layerInfo->mutable_visible_region(); });
2015 LayerProtoHelper::writeToProto(surfaceDamageRegion,
2016 [&]() { return layerInfo->mutable_damage_region(); });
chaviwddeae262020-01-06 10:31:23 -08002017
2018 if (hasColorTransform()) {
2019 LayerProtoHelper::writeToProto(getColorTransform(),
2020 layerInfo->mutable_color_transform());
2021 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07002022 }
2023
2024 if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
2025 LayerProtoHelper::writeToProto(mSourceBounds,
2026 [&]() { return layerInfo->mutable_source_bounds(); });
2027 LayerProtoHelper::writeToProto(mScreenBounds,
2028 [&]() { return layerInfo->mutable_screen_bounds(); });
Vishnu Nair95a1ed42019-12-06 12:25:11 -08002029 LayerProtoHelper::writeToProto(getRoundedCornerState().cropRect,
2030 [&]() { return layerInfo->mutable_corner_radius_crop(); });
2031 layerInfo->set_shadow_radius(mEffectiveShadowRadius);
Vishnu Nair8406fd72019-07-30 11:29:31 -07002032 }
2033}
2034
2035void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,
2036 uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07002037 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2038 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002039 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw1d044282017-09-27 12:19:28 -07002040
Peiyong Linefefaac2018-08-17 12:27:51 -07002041 ui::Transform requestedTransform = state.active_legacy.transform;
chaviw1d044282017-09-27 12:19:28 -07002042
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002043 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
2044 layerInfo->set_id(sequence);
2045 layerInfo->set_name(getName().c_str());
chaviw8a01fa42019-08-19 12:39:31 -07002046 layerInfo->set_type(getType());
chaviw1d044282017-09-27 12:19:28 -07002047
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002048 for (const auto& child : children) {
2049 layerInfo->add_children(child->sequence);
chaviw1d044282017-09-27 12:19:28 -07002050 }
chaviw1d044282017-09-27 12:19:28 -07002051
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002052 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
2053 sp<Layer> strongRelative = weakRelative.promote();
2054 if (strongRelative != nullptr) {
2055 layerInfo->add_relatives(strongRelative->sequence);
2056 }
chaviwadc40c22018-07-10 16:57:27 -07002057 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002058
2059 LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,
2060 [&]() { return layerInfo->mutable_transparent_region(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002061
2062 layerInfo->set_layer_stack(getLayerStack());
2063 layerInfo->set_z(state.z);
2064
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002065 LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),
2066 [&]() {
2067 return layerInfo->mutable_requested_position();
2068 });
2069
2070 LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h,
2071 [&]() { return layerInfo->mutable_size(); });
2072
2073 LayerProtoHelper::writeToProto(state.crop_legacy,
2074 [&]() { return layerInfo->mutable_crop(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002075
2076 layerInfo->set_is_opaque(isOpaque(state));
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002077
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002078
2079 layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));
2080 LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
2081 LayerProtoHelper::writeToProto(state.color,
2082 [&]() { return layerInfo->mutable_requested_color(); });
2083 layerInfo->set_flags(state.flags);
2084
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002085 LayerProtoHelper::writeToProto(requestedTransform,
2086 layerInfo->mutable_requested_transform());
2087
2088 auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();
2089 if (parent != nullptr) {
2090 layerInfo->set_parent(parent->sequence);
2091 } else {
2092 layerInfo->set_parent(-1);
2093 }
2094
2095 auto zOrderRelativeOf = state.zOrderRelativeOf.promote();
2096 if (zOrderRelativeOf != nullptr) {
2097 layerInfo->set_z_order_relative_of(zOrderRelativeOf->sequence);
2098 } else {
2099 layerInfo->set_z_order_relative_of(-1);
2100 }
chaviw08f3cb22020-01-13 13:17:21 -08002101
2102 layerInfo->set_is_relative_of(state.isRelativeOf);
chaviwadc40c22018-07-10 16:57:27 -07002103 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002104
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002105 if (traceFlags & SurfaceTracing::TRACE_INPUT) {
2106 LayerProtoHelper::writeToProto(state.inputInfo, state.touchableRegionCrop,
2107 [&]() { return layerInfo->mutable_input_window_info(); });
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002108 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002109
2110 if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
2111 auto protoMap = layerInfo->mutable_metadata();
2112 for (const auto& entry : state.metadata.mMap) {
2113 (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());
2114 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002115 }
chaviw1d044282017-09-27 12:19:28 -07002116}
2117
Robert Carr2e102c92018-10-23 12:11:15 -07002118bool Layer::isRemovedFromCurrentState() const {
2119 return mRemovedFromCurrentState;
2120}
2121
Arthur Hungd20b2702019-01-14 18:16:16 +08002122InputWindowInfo Layer::fillInputInfo() {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002123 InputWindowInfo info = mDrawingState.inputInfo;
chaviwaf87b3e2019-10-01 16:59:28 -07002124 info.id = sequence;
Robert Carr720e5062018-07-30 17:45:14 -07002125
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002126 if (info.displayId == ADISPLAY_ID_NONE) {
chaviwb15ea8a2019-09-03 12:40:22 -07002127 info.displayId = getLayerStack();
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002128 }
2129
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002130 ui::Transform t = getTransform();
2131 const float xScale = t.sx();
2132 const float yScale = t.sy();
Ady Abraham282f1d72019-07-24 18:05:56 -07002133 int32_t xSurfaceInset = info.surfaceInset;
2134 int32_t ySurfaceInset = info.surfaceInset;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002135 if (xScale != 1.0f || yScale != 1.0f) {
Ady Abraham282f1d72019-07-24 18:05:56 -07002136 info.windowXScale *= (xScale != 0.0f) ? 1.0f / xScale : 0.0f;
2137 info.windowYScale *= (yScale != 0.0f) ? 1.0f / yScale : 0.0f;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002138 info.touchableRegion.scaleSelf(xScale, yScale);
Ady Abraham282f1d72019-07-24 18:05:56 -07002139 xSurfaceInset = std::round(xSurfaceInset * xScale);
2140 ySurfaceInset = std::round(ySurfaceInset * yScale);
Riddle Hsu39d4aa52018-11-30 20:46:53 +08002141 }
Robert Carre07e1032018-11-26 12:55:53 -08002142
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002143 // Transform layer size to screen space and inset it by surface insets.
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002144 // If this is a portal window, set the touchableRegion to the layerBounds.
2145 Rect layerBounds = info.portalToDisplayId == ADISPLAY_ID_NONE
2146 ? getBufferSize(getDrawingState())
2147 : info.touchableRegion.getBounds();
Arthur Hungd20b2702019-01-14 18:16:16 +08002148 if (!layerBounds.isValid()) {
2149 layerBounds = getCroppedBufferSize(getDrawingState());
2150 }
Vishnu Nair8033a492018-12-05 07:27:23 -08002151 layerBounds = t.transform(layerBounds);
Ady Abraham282f1d72019-07-24 18:05:56 -07002152
2153 // clamp inset to layer bounds
2154 xSurfaceInset = (xSurfaceInset >= 0) ? std::min(xSurfaceInset, layerBounds.getWidth() / 2) : 0;
2155 ySurfaceInset = (ySurfaceInset >= 0) ? std::min(ySurfaceInset, layerBounds.getHeight() / 2) : 0;
2156
Arthur Hung118b1142019-05-08 21:25:59 +08002157 layerBounds.inset(xSurfaceInset, ySurfaceInset, xSurfaceInset, ySurfaceInset);
Vishnu Nair8033a492018-12-05 07:27:23 -08002158
Arthur Hungd20b2702019-01-14 18:16:16 +08002159 // Input coordinate should match the layer bounds.
2160 info.frameLeft = layerBounds.left;
2161 info.frameTop = layerBounds.top;
2162 info.frameRight = layerBounds.right;
2163 info.frameBottom = layerBounds.bottom;
Vishnu Nair8033a492018-12-05 07:27:23 -08002164
2165 // Position the touchable region relative to frame screen location and restrict it to frame
2166 // bounds.
2167 info.touchableRegion = info.touchableRegion.translate(info.frameLeft, info.frameTop);
chaviw3e727cd2019-01-31 13:41:05 -08002168 info.visible = canReceiveInput();
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002169
2170 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2171 if (info.replaceTouchableRegionWithCrop) {
2172 if (cropLayer == nullptr) {
2173 info.touchableRegion = Region(Rect{mScreenBounds});
2174 } else {
2175 info.touchableRegion = Region(Rect{cropLayer->mScreenBounds});
2176 }
2177 } else if (cropLayer != nullptr) {
2178 info.touchableRegion = info.touchableRegion.intersect(Rect{cropLayer->mScreenBounds});
2179 }
2180
chaviwaf87b3e2019-10-01 16:59:28 -07002181 // If the layer is a clone, we need to crop the input region to cloned root to prevent
2182 // touches from going outside the cloned area.
2183 if (isClone()) {
2184 sp<Layer> clonedRoot = getClonedRoot();
2185 if (clonedRoot != nullptr) {
2186 Rect rect(clonedRoot->mScreenBounds);
2187 info.touchableRegion = info.touchableRegion.intersect(rect);
2188 }
2189 }
2190
Robert Carr720e5062018-07-30 17:45:14 -07002191 return info;
2192}
2193
chaviwaf87b3e2019-10-01 16:59:28 -07002194sp<Layer> Layer::getClonedRoot() {
2195 if (mClonedChild != nullptr) {
2196 return this;
2197 }
2198 if (mDrawingParent == nullptr || mDrawingParent.promote() == nullptr) {
2199 return nullptr;
2200 }
2201 return mDrawingParent.promote()->getClonedRoot();
2202}
2203
Robert Carr720e5062018-07-30 17:45:14 -07002204bool Layer::hasInput() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002205 return mDrawingState.inputInfo.token != nullptr;
Robert Carr720e5062018-07-30 17:45:14 -07002206}
2207
Lloyd Piquefeb73d72018-12-04 17:23:44 -08002208std::shared_ptr<compositionengine::Layer> Layer::getCompositionLayer() const {
2209 return nullptr;
2210}
2211
chaviw3e727cd2019-01-31 13:41:05 -08002212bool Layer::canReceiveInput() const {
Vishnu Nair82353e92019-09-12 12:38:47 -07002213 return !isHiddenByPolicy();
chaviw3e727cd2019-01-31 13:41:05 -08002214}
2215
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002216compositionengine::OutputLayer* Layer::findOutputLayerForDisplay(
2217 const sp<const DisplayDevice>& display) const {
2218 return display->getCompositionDisplay()->getOutputLayerForLayer(getCompositionLayer().get());
2219}
2220
Lloyd Piquea2468662019-03-07 21:31:06 -08002221Region Layer::debugGetVisibleRegionOnDefaultDisplay() const {
2222 sp<DisplayDevice> displayDevice = mFlinger->getDefaultDisplayDeviceLocked();
2223 if (displayDevice == nullptr) {
2224 return {};
2225 }
2226
2227 auto outputLayer = findOutputLayerForDisplay(displayDevice);
2228 if (outputLayer == nullptr) {
2229 return {};
2230 }
2231
2232 return outputLayer->getState().visibleRegion;
2233}
2234
chaviwb4c6e582019-08-16 14:35:07 -07002235void Layer::setInitialValuesForClone(const sp<Layer>& clonedFrom) {
2236 // copy drawing state from cloned layer
2237 mDrawingState = clonedFrom->mDrawingState;
2238 mClonedFrom = clonedFrom;
chaviwb4c6e582019-08-16 14:35:07 -07002239}
chaviw74b03172019-08-19 11:09:03 -07002240
2241void Layer::updateMirrorInfo() {
2242 if (mClonedChild == nullptr || !mClonedChild->isClonedFromAlive()) {
2243 // If mClonedChild is null, there is nothing to mirror. If isClonedFromAlive returns false,
2244 // it means that there is a clone, but the layer it was cloned from has been destroyed. In
2245 // that case, we want to delete the reference to the clone since we want it to get
2246 // destroyed. The root, this layer, will still be around since the client can continue
2247 // to hold a reference, but no cloned layers will be displayed.
2248 mClonedChild = nullptr;
2249 return;
2250 }
2251
2252 std::map<sp<Layer>, sp<Layer>> clonedLayersMap;
2253 // If the real layer exists and is in current state, add the clone as a child of the root.
2254 // There's no need to remove from drawingState when the layer is offscreen since currentState is
2255 // copied to drawingState for the root layer. So the clonedChild is always removed from
2256 // drawingState and then needs to be added back each traversal.
2257 if (!mClonedChild->getClonedFrom()->isRemovedFromCurrentState()) {
2258 addChildToDrawing(mClonedChild);
2259 }
2260
2261 mClonedChild->updateClonedDrawingState(clonedLayersMap);
2262 mClonedChild->updateClonedChildren(this, clonedLayersMap);
2263 mClonedChild->updateClonedRelatives(clonedLayersMap);
2264}
2265
2266void Layer::updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2267 // If the layer the clone was cloned from is alive, copy the content of the drawingState
2268 // to the clone. If the real layer is no longer alive, continue traversing the children
2269 // since we may be able to pull out other children that are still alive.
2270 if (isClonedFromAlive()) {
2271 sp<Layer> clonedFrom = getClonedFrom();
2272 mDrawingState = clonedFrom->mDrawingState;
chaviw74b03172019-08-19 11:09:03 -07002273 clonedLayersMap.emplace(clonedFrom, this);
2274 }
2275
2276 // The clone layer may have children in drawingState since they may have been created and
2277 // added from a previous request to updateMirorInfo. This is to ensure we don't recreate clones
2278 // that already exist, since we can just re-use them.
2279 // The drawingChildren will not get overwritten by the currentChildren since the clones are
2280 // not updated in the regular traversal. They are skipped since the root will lose the
2281 // reference to them when it copies its currentChildren to drawing.
2282 for (sp<Layer>& child : mDrawingChildren) {
2283 child->updateClonedDrawingState(clonedLayersMap);
2284 }
2285}
2286
2287void Layer::updateClonedChildren(const sp<Layer>& mirrorRoot,
2288 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2289 mDrawingChildren.clear();
2290
2291 if (!isClonedFromAlive()) {
2292 return;
2293 }
2294
2295 sp<Layer> clonedFrom = getClonedFrom();
2296 for (sp<Layer>& child : clonedFrom->mDrawingChildren) {
2297 if (child == mirrorRoot) {
2298 // This is to avoid cyclical mirroring.
2299 continue;
2300 }
2301 sp<Layer> clonedChild = clonedLayersMap[child];
2302 if (clonedChild == nullptr) {
2303 clonedChild = child->createClone();
2304 clonedLayersMap[child] = clonedChild;
2305 }
2306 addChildToDrawing(clonedChild);
2307 clonedChild->updateClonedChildren(mirrorRoot, clonedLayersMap);
2308 }
2309}
2310
chaviwaf87b3e2019-10-01 16:59:28 -07002311void Layer::updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2312 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2313 if (cropLayer != nullptr) {
2314 if (clonedLayersMap.count(cropLayer) == 0) {
2315 // Real layer had a crop layer but it's not in the cloned hierarchy. Just set to
2316 // self as crop layer to avoid going outside bounds.
2317 mDrawingState.touchableRegionCrop = this;
2318 } else {
2319 const sp<Layer>& clonedCropLayer = clonedLayersMap.at(cropLayer);
2320 mDrawingState.touchableRegionCrop = clonedCropLayer;
2321 }
2322 }
2323 // Cloned layers shouldn't handle watch outside since their z order is not determined by
2324 // WM or the client.
2325 mDrawingState.inputInfo.layoutParamsFlags &= ~InputWindowInfo::FLAG_WATCH_OUTSIDE_TOUCH;
2326}
2327
2328void Layer::updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
chaviw74b03172019-08-19 11:09:03 -07002329 mDrawingState.zOrderRelativeOf = nullptr;
2330 mDrawingState.zOrderRelatives.clear();
2331
2332 if (!isClonedFromAlive()) {
2333 return;
2334 }
2335
chaviwaf87b3e2019-10-01 16:59:28 -07002336 const sp<Layer>& clonedFrom = getClonedFrom();
chaviw74b03172019-08-19 11:09:03 -07002337 for (wp<Layer>& relativeWeak : clonedFrom->mDrawingState.zOrderRelatives) {
chaviwaf87b3e2019-10-01 16:59:28 -07002338 const sp<Layer>& relative = relativeWeak.promote();
2339 if (clonedLayersMap.count(relative) > 0) {
2340 auto& clonedRelative = clonedLayersMap.at(relative);
chaviw74b03172019-08-19 11:09:03 -07002341 mDrawingState.zOrderRelatives.add(clonedRelative);
2342 }
2343 }
2344
2345 // Check if the relativeLayer for the real layer is part of the cloned hierarchy.
2346 // It's possible that the layer it's relative to is outside the requested cloned hierarchy.
2347 // In that case, we treat the layer as if the relativeOf has been removed. This way, it will
2348 // still traverse the children, but the layer with the missing relativeOf will not be shown
2349 // on screen.
chaviwaf87b3e2019-10-01 16:59:28 -07002350 const sp<Layer>& relativeOf = clonedFrom->mDrawingState.zOrderRelativeOf.promote();
2351 if (clonedLayersMap.count(relativeOf) > 0) {
2352 const sp<Layer>& clonedRelativeOf = clonedLayersMap.at(relativeOf);
chaviw74b03172019-08-19 11:09:03 -07002353 mDrawingState.zOrderRelativeOf = clonedRelativeOf;
2354 }
2355
chaviwaf87b3e2019-10-01 16:59:28 -07002356 updateClonedInputInfo(clonedLayersMap);
2357
chaviw74b03172019-08-19 11:09:03 -07002358 for (sp<Layer>& child : mDrawingChildren) {
2359 child->updateClonedRelatives(clonedLayersMap);
2360 }
2361}
2362
2363void Layer::addChildToDrawing(const sp<Layer>& layer) {
2364 mDrawingChildren.add(layer);
2365 layer->mDrawingParent = this;
2366}
2367
Mathias Agopian13127d82013-03-05 17:47:11 -08002368// ---------------------------------------------------------------------------
2369
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002370}; // namespace android
Mathias Agopian3f844832013-08-07 21:24:32 -07002371
2372#if defined(__gl_h_)
2373#error "don't include gl/gl.h in this file"
2374#endif
2375
2376#if defined(__gl2_h_)
2377#error "don't include gl2/gl2.h in this file"
2378#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08002379
2380// TODO(b/129481165): remove the #pragma below and fix conversion issues
2381#pragma clang diagnostic pop // ignored "-Wconversion"