blob: b952eb63009a4b0a4a16cd7510eddf404cbde4ce [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>
Steven Thomas62a4cf82020-01-31 12:04:03 -080029#include <android/native_window.h>
Vishnu Nair0f085c62019-08-30 08:49:12 -070030#include <binder/IPCThreadState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080031#include <compositionengine/Display.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"
Mathias Agopian3e25fd82013-04-22 17:52:16 +020060#include "Colorizer.h"
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -070061#include "DisplayDevice.h"
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080062#include "DisplayHardware/HWComposer.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080063#include "EffectLayer.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 uint32_t layerFlags = 0;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070085 if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
86 if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
87 if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;
Mathias Agopian4d9b8222013-03-12 17:11:48 -070088
Lloyd Pique0449b0f2018-12-20 16:23:45 -080089 mCurrentState.active_legacy.w = args.w;
90 mCurrentState.active_legacy.h = args.h;
91 mCurrentState.flags = layerFlags;
92 mCurrentState.active_legacy.transform.set(0, 0);
93 mCurrentState.crop_legacy.makeInvalid();
94 mCurrentState.requestedCrop_legacy = mCurrentState.crop_legacy;
95 mCurrentState.z = 0;
96 mCurrentState.color.a = 1.0f;
97 mCurrentState.layerStack = 0;
98 mCurrentState.sequence = 0;
99 mCurrentState.requested_legacy = mCurrentState.active_legacy;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800100 mCurrentState.active.w = UINT32_MAX;
101 mCurrentState.active.h = UINT32_MAX;
102 mCurrentState.active.transform.set(0, 0);
Valerie Hau134651a2020-01-28 16:21:22 -0800103 mCurrentState.frameNumber = 0;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800104 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;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700119 mCurrentState.treeHasFrameRateVote = false;
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
chaviwde94d0f2020-01-22 13:11:25 -0800147LayerCreationArgs::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
Vishnu Nairfa247b12020-02-11 08:58:26 -0800169 * EffectLayer object, it's essentially a NOP.
David Sodmaneb085e02017-10-05 18:49:04 -0700170 */
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 Piquede196652020-01-22 17:29:58 -0800418void Layer::prepareBasicGeometryCompositionState() {
Lloyd Piquec6687342019-03-07 21:34:57 -0800419 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
Lloyd Piquede196652020-01-22 17:29:58 -0800431 auto* compositionState = editCompositionState();
432 compositionState->layerStackId =
Lloyd Piquec6687342019-03-07 21:34:57 -0800433 (layerStack != ~0u) ? std::make_optional(layerStack) : std::nullopt;
Lloyd Piquede196652020-01-22 17:29:58 -0800434 compositionState->internalOnly = getPrimaryDisplayOnly();
435 compositionState->isVisible = isVisible();
436 compositionState->isOpaque = opaque && !usesRoundedCorners && alpha == 1.f;
437 compositionState->shadowRadius = mEffectiveShadowRadius;
Lloyd Piquec6687342019-03-07 21:34:57 -0800438
Lloyd Piquede196652020-01-22 17:29:58 -0800439 compositionState->contentDirty = contentDirty;
Lloyd Piquec6687342019-03-07 21:34:57 -0800440 contentDirty = false;
441
Lloyd Piquede196652020-01-22 17:29:58 -0800442 compositionState->geomLayerBounds = mBounds;
443 compositionState->geomLayerTransform = getTransform();
444 compositionState->geomInverseLayerTransform = compositionState->geomLayerTransform.inverse();
445 compositionState->transparentRegionHint = getActiveTransparentRegion(drawingState);
Lloyd Piquec6687342019-03-07 21:34:57 -0800446
Lloyd Piquede196652020-01-22 17:29:58 -0800447 compositionState->blendMode = static_cast<Hwc2::IComposerClient::BlendMode>(blendMode);
448 compositionState->alpha = alpha;
449 compositionState->backgroundBlurRadius = drawingState.backgroundBlurRadius;
Lloyd Piquec6687342019-03-07 21:34:57 -0800450}
451
Lloyd Piquede196652020-01-22 17:29:58 -0800452void Layer::prepareGeometryCompositionState() {
Lloyd Piquea83776c2019-01-29 18:42:32 -0800453 const auto& drawingState{getDrawingState()};
Mathias Agopian13127d82013-03-05 17:47:11 -0800454
Lloyd Piquea83776c2019-01-29 18:42:32 -0800455 int type = drawingState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
456 int appId = drawingState.metadata.getInt32(METADATA_OWNER_UID, 0);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700457 sp<Layer> parent = mDrawingParent.promote();
Albert Chaulk2a589632017-05-04 16:59:44 -0400458 if (parent.get()) {
459 auto& parentState = parent->getDrawingState();
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800460 const int parentType = parentState.metadata.getInt32(METADATA_WINDOW_TYPE, 0);
461 const int parentAppId = parentState.metadata.getInt32(METADATA_OWNER_UID, 0);
Jiwen 'Steve' Cai736c74e2019-05-28 18:33:22 -0700462 if (parentType > 0 && parentAppId > 0) {
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800463 type = parentType;
464 appId = parentAppId;
rongliucfb187b2018-03-14 12:26:23 -0700465 }
Albert Chaulk2a589632017-05-04 16:59:44 -0400466 }
467
Lloyd Piquede196652020-01-22 17:29:58 -0800468 auto* compositionState = editCompositionState();
David Sodman15094112018-10-11 09:39:37 -0700469
Lloyd Piquede196652020-01-22 17:29:58 -0800470 compositionState->geomBufferSize = getBufferSize(drawingState);
471 compositionState->geomContentCrop = getBufferCrop();
472 compositionState->geomCrop = getCrop(drawingState);
473 compositionState->geomBufferTransform = getBufferTransform();
474 compositionState->geomBufferUsesDisplayInverseTransform = getTransformToDisplayInverse();
475 compositionState->geomUsesSourceCrop = usesSourceCrop();
476 compositionState->isSecure = isSecure();
477
478 compositionState->type = type;
479 compositionState->appId = appId;
Lloyd Pique8d9f8362020-02-11 19:13:09 -0800480
481 compositionState->metadata.clear();
482 const auto& supportedMetadata = mFlinger->getHwComposer().getSupportedLayerGenericMetadata();
483 for (const auto& [key, mandatory] : supportedMetadata) {
484 const auto& genericLayerMetadataCompatibilityMap =
485 mFlinger->getGenericLayerMetadataKeyMap();
486 auto compatIter = genericLayerMetadataCompatibilityMap.find(key);
487 if (compatIter == std::end(genericLayerMetadataCompatibilityMap)) {
488 continue;
489 }
490 const uint32_t id = compatIter->second;
491
492 auto it = drawingState.metadata.mMap.find(id);
493 if (it == std::end(drawingState.metadata.mMap)) {
494 continue;
495 }
496
497 compositionState->metadata
498 .emplace(key, compositionengine::GenericLayerMetadataEntry{mandatory, it->second});
499 }
Lloyd Piquea83776c2019-01-29 18:42:32 -0800500}
David Sodmanba340492018-08-05 21:51:33 -0700501
Lloyd Piquede196652020-01-22 17:29:58 -0800502void Layer::preparePerFrameCompositionState() {
Lloyd Pique688abd42019-02-15 15:42:24 -0800503 const auto& drawingState{getDrawingState()};
Lloyd Piquede196652020-01-22 17:29:58 -0800504 auto* compositionState = editCompositionState();
Lloyd Piquef5275482019-01-29 18:42:42 -0800505
Lloyd Piquede196652020-01-22 17:29:58 -0800506 compositionState->forceClientComposition = false;
507
508 compositionState->isColorspaceAgnostic = isColorSpaceAgnostic();
509 compositionState->dataspace = getDataSpace();
510 compositionState->colorTransform = getColorTransform();
511 compositionState->colorTransformIsIdentity = !hasColorTransform();
512 compositionState->surfaceDamage = surfaceDamageRegion;
513 compositionState->hasProtectedContent = isProtected();
Lloyd Pique688abd42019-02-15 15:42:24 -0800514
515 const bool usesRoundedCorners = getRoundedCornerState().radius != 0.f;
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700516
Lloyd Piquede196652020-01-22 17:29:58 -0800517 compositionState->isOpaque =
Lloyd Pique688abd42019-02-15 15:42:24 -0800518 isOpaque(drawingState) && !usesRoundedCorners && getAlpha() == 1.0_hf;
Lloyd Piquef5275482019-01-29 18:42:42 -0800519
520 // Force client composition for special cases known only to the front-end.
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800521 if (isHdrY410() || usesRoundedCorners || drawShadows()) {
Lloyd Piquede196652020-01-22 17:29:58 -0800522 compositionState->forceClientComposition = true;
Lloyd Piquef5275482019-01-29 18:42:42 -0800523 }
524}
525
Lloyd Piquede196652020-01-22 17:29:58 -0800526void Layer::prepareCursorCompositionState() {
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800527 const State& drawingState{getDrawingState()};
Lloyd Piquede196652020-01-22 17:29:58 -0800528 auto* compositionState = editCompositionState();
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800529
530 // Apply the layer's transform, followed by the display's global transform
531 // Here we're guaranteed that the layer's transform preserves rects
532 Rect win = getCroppedBufferSize(drawingState);
533 // Subtract the transparent region and snap to the bounds
534 Rect bounds = reduce(win, getActiveTransparentRegion(drawingState));
535 Rect frame(getTransform().transform(bounds));
536
Lloyd Piquede196652020-01-22 17:29:58 -0800537 compositionState->cursorFrame = frame;
538}
539
540sp<compositionengine::LayerFE> Layer::asLayerFE() const {
541 return const_cast<compositionengine::LayerFE*>(
542 static_cast<const compositionengine::LayerFE*>(this));
543}
544
545sp<compositionengine::LayerFE> Layer::getCompositionEngineLayerFE() const {
546 return nullptr;
547}
548
549compositionengine::LayerFECompositionState* Layer::editCompositionState() {
550 return nullptr;
551}
552
553const compositionengine::LayerFECompositionState* Layer::getCompositionState() const {
554 return nullptr;
Lloyd Piquec7b0c752019-03-07 20:59:59 -0800555}
556
Lloyd Piquef16688f2019-02-19 17:47:57 -0800557bool Layer::onPreComposition(nsecs_t) {
558 return false;
559}
560
Lloyd Piquede196652020-01-22 17:29:58 -0800561void Layer::prepareCompositionState(compositionengine::LayerFE::StateSubset subset) {
Lloyd Piquec6687342019-03-07 21:34:57 -0800562 using StateSubset = compositionengine::LayerFE::StateSubset;
Lloyd Piquef5275482019-01-29 18:42:42 -0800563
Lloyd Piquec6687342019-03-07 21:34:57 -0800564 switch (subset) {
565 case StateSubset::BasicGeometry:
Lloyd Piquede196652020-01-22 17:29:58 -0800566 prepareBasicGeometryCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800567 break;
568
569 case StateSubset::GeometryAndContent:
Lloyd Piquede196652020-01-22 17:29:58 -0800570 prepareBasicGeometryCompositionState();
571 prepareGeometryCompositionState();
572 preparePerFrameCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800573 break;
574
575 case StateSubset::Content:
Lloyd Piquede196652020-01-22 17:29:58 -0800576 preparePerFrameCompositionState();
577 break;
578
579 case StateSubset::Cursor:
580 prepareCursorCompositionState();
Lloyd Piquec6687342019-03-07 21:34:57 -0800581 break;
582 }
Lloyd Piquea83776c2019-01-29 18:42:32 -0800583}
Mathias Agopian29a367b2011-07-12 14:51:45 -0700584
Lloyd Piquea83776c2019-01-29 18:42:32 -0800585const char* Layer::getDebugName() const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700586 return mName.c_str();
David Sodman4b7c4bc2017-11-17 12:13:59 -0800587}
588
Mathias Agopian13127d82013-03-05 17:47:11 -0800589// ---------------------------------------------------------------------------
590// drawing...
591// ---------------------------------------------------------------------------
592
Vishnu Nair9b079a22020-01-21 14:36:08 -0800593std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareClientComposition(
Lloyd Piquef16688f2019-02-19 17:47:57 -0800594 compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
Lloyd Piquede196652020-01-22 17:29:58 -0800595 if (!getCompositionState()) {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800596 return {};
597 }
Mathias Agopian13127d82013-03-05 17:47:11 -0800598
Vishnu Nair4351ad52019-02-11 14:13:02 -0800599 FloatRect bounds = getBounds();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000600 half alpha = getAlpha();
Vishnu Nair9b079a22020-01-21 14:36:08 -0800601
602 compositionengine::LayerFE::LayerSettings layerSettings;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800603 layerSettings.geometry.boundaries = bounds;
604 if (targetSettings.useIdentityTransform) {
605 layerSettings.geometry.positionTransform = mat4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000606 } else {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800607 layerSettings.geometry.positionTransform = getTransform().asMatrix4();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000608 }
609
610 if (hasColorTransform()) {
Lloyd Piquef16688f2019-02-19 17:47:57 -0800611 layerSettings.colorTransform = getColorTransform();
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000612 }
613
614 const auto roundedCornerState = getRoundedCornerState();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800615 layerSettings.geometry.roundedCornersRadius = roundedCornerState.radius;
616 layerSettings.geometry.roundedCornersCrop = roundedCornerState.cropRect;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000617
Lloyd Piquef16688f2019-02-19 17:47:57 -0800618 layerSettings.alpha = alpha;
chaviw4244e032019-09-04 11:27:49 -0700619 layerSettings.sourceDataspace = getDataSpace();
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800620 layerSettings.backgroundBlurRadius = getBackgroundBlurRadius();
Lloyd Piquef16688f2019-02-19 17:47:57 -0800621 return layerSettings;
Mathias Agopian13127d82013-03-05 17:47:11 -0800622}
623
Vishnu Nair9b079a22020-01-21 14:36:08 -0800624std::optional<compositionengine::LayerFE::LayerSettings> Layer::prepareShadowClientComposition(
625 const LayerFE::LayerSettings& casterLayerSettings, const Rect& displayViewport,
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800626 ui::Dataspace outputDataspace) {
627 renderengine::ShadowSettings shadow = getShadowSettings(displayViewport);
628 if (shadow.length <= 0.f) {
629 return {};
630 }
631
632 const float casterAlpha = casterLayerSettings.alpha;
633 const bool casterIsOpaque = ((casterLayerSettings.source.buffer.buffer != nullptr) &&
634 casterLayerSettings.source.buffer.isOpaque);
635
Vishnu Nair9b079a22020-01-21 14:36:08 -0800636 compositionengine::LayerFE::LayerSettings shadowLayer = casterLayerSettings;
637
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800638 shadowLayer.shadow = shadow;
Vishnu Naira483b4a2019-12-12 15:07:52 -0800639 shadowLayer.geometry.boundaries = mBounds; // ignore transparent region
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800640
641 // If the casting layer is translucent, we need to fill in the shadow underneath the layer.
642 // Otherwise the generated shadow will only be shown around the casting layer.
643 shadowLayer.shadow.casterIsTranslucent = !casterIsOpaque || (casterAlpha < 1.0f);
644 shadowLayer.shadow.ambientColor *= casterAlpha;
645 shadowLayer.shadow.spotColor *= casterAlpha;
646 shadowLayer.sourceDataspace = outputDataspace;
647 shadowLayer.source.buffer.buffer = nullptr;
Vishnu Nair9b079a22020-01-21 14:36:08 -0800648 shadowLayer.source.buffer.fence = nullptr;
649 shadowLayer.frameNumber = 0;
650 shadowLayer.bufferId = 0;
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800651
652 if (shadowLayer.shadow.ambientColor.a <= 0.f && shadowLayer.shadow.spotColor.a <= 0.f) {
653 return {};
654 }
655
656 float casterCornerRadius = shadowLayer.geometry.roundedCornersRadius;
Vishnu Nair9b079a22020-01-21 14:36:08 -0800657 const FloatRect& cornerRadiusCropRect = shadowLayer.geometry.roundedCornersCrop;
Vishnu Nair3a7346c2019-12-04 08:09:09 -0800658 const FloatRect& casterRect = shadowLayer.geometry.boundaries;
659
660 // crop used to set the corner radius may be larger than the content rect. Adjust the corner
661 // radius accordingly.
662 if (casterCornerRadius > 0.f) {
663 float cropRectOffset = std::max(std::abs(cornerRadiusCropRect.top - casterRect.top),
664 std::abs(cornerRadiusCropRect.left - casterRect.left));
665 if (cropRectOffset > casterCornerRadius) {
666 casterCornerRadius = 0;
667 } else {
668 casterCornerRadius -= cropRectOffset;
669 }
670 shadowLayer.geometry.roundedCornersRadius = casterCornerRadius;
671 }
672
673 return shadowLayer;
674}
675
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800676void Layer::prepareClearClientComposition(LayerFE::LayerSettings& layerSettings,
677 bool blackout) const {
678 layerSettings.source.buffer.buffer = nullptr;
679 layerSettings.source.solidColor = half3(0.0, 0.0, 0.0);
680 layerSettings.disableBlending = true;
Vishnu Nair3b653e72020-02-24 16:40:50 -0800681 layerSettings.bufferId = 0;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800682 layerSettings.frameNumber = 0;
683
684 // If layer is blacked out, force alpha to 1 so that we draw a black color layer.
685 layerSettings.alpha = blackout ? 1.0f : 0.0f;
686}
687
688std::vector<compositionengine::LayerFE::LayerSettings> Layer::prepareClientCompositionList(
689 compositionengine::LayerFE::ClientCompositionTargetSettings& targetSettings) {
690 std::optional<compositionengine::LayerFE::LayerSettings> layerSettings =
691 prepareClientComposition(targetSettings);
692 // Nothing to render.
693 if (!layerSettings) {
694 return {};
695 }
696
697 // HWC requests to clear this layer.
698 if (targetSettings.clearContent) {
699 prepareClearClientComposition(*layerSettings, false /* blackout */);
700 return {*layerSettings};
701 }
702
703 std::optional<compositionengine::LayerFE::LayerSettings> shadowSettings =
704 prepareShadowClientComposition(*layerSettings, targetSettings.viewport,
705 targetSettings.dataspace);
706 // There are no shadows to render.
707 if (!shadowSettings) {
708 return {*layerSettings};
709 }
710
711 // If the layer casts a shadow but the content casting the shadow is occluded, skip
712 // composing the non-shadow content and only draw the shadows.
713 if (targetSettings.realContentIsVisible) {
714 return {*shadowSettings, *layerSettings};
715 }
716
717 return {*shadowSettings};
718}
719
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800720Hwc2::IComposerClient::Composition Layer::getCompositionType(
721 const sp<const DisplayDevice>& display) const {
722 const auto outputLayer = findOutputLayerForDisplay(display);
Alec Mouri6b9e9912020-01-21 10:50:24 -0800723 if (outputLayer == nullptr) {
724 return Hwc2::IComposerClient::Composition::INVALID;
725 }
726 if (outputLayer->getState().hwc) {
727 return (*outputLayer->getState().hwc).hwcCompositionType;
728 } else {
729 return Hwc2::IComposerClient::Composition::CLIENT;
730 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800731}
732
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800733bool Layer::getClearClientTarget(const sp<const DisplayDevice>& display) const {
734 const auto outputLayer = findOutputLayerForDisplay(display);
735 LOG_FATAL_IF(!outputLayer);
736 return outputLayer->getState().clearClientTarget;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800737}
Dan Stoza9e56aa02015-11-02 13:00:03 -0800738
Dan Stozacac35382016-01-27 12:21:06 -0800739bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
740 if (point->getFrameNumber() <= mCurrentFrameNumber) {
741 // Don't bother with a SyncPoint, since we've already latched the
742 // relevant frame
743 return false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700744 }
Robert Carr2e102c92018-10-23 12:11:15 -0700745 if (isRemovedFromCurrentState()) {
746 return false;
747 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700748
Dan Stozacac35382016-01-27 12:21:06 -0800749 Mutex::Autolock lock(mLocalSyncPointMutex);
750 mLocalSyncPoints.push_back(point);
751 return true;
Dan Stoza7dde5992015-05-22 09:51:44 -0700752}
753
Mathias Agopian13127d82013-03-05 17:47:11 -0800754// ----------------------------------------------------------------------------
755// local state
756// ----------------------------------------------------------------------------
757
David Sodman41fdfc92017-11-06 16:09:56 -0800758bool Layer::isSecure() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800759 const State& s(mDrawingState);
Dan Stoza23116082015-06-18 14:58:39 -0700760 return (s.flags & layer_state_t::eLayerSecure);
761}
762
Mathias Agopian13127d82013-03-05 17:47:11 -0800763// ----------------------------------------------------------------------------
764// transaction
765// ----------------------------------------------------------------------------
Ady Abraham83729882018-12-07 12:26:48 -0800766
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800767void Layer::pushPendingState() {
768 if (!mCurrentState.modified) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700769 return;
770 }
Alec Mourie60041e2019-06-14 18:59:51 -0700771 ATRACE_CALL();
Dan Stoza7dde5992015-05-22 09:51:44 -0700772
Dan Stoza7dde5992015-05-22 09:51:44 -0700773 // If this transaction is waiting on the receipt of a frame, generate a sync
774 // point and send it to the remote layer.
Robert Carr2e102c92018-10-23 12:11:15 -0700775 // We don't allow installing sync points after we are removed from the current state
776 // as we won't be able to signal our end.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800777 if (mCurrentState.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) {
778 sp<Layer> barrierLayer = mCurrentState.barrierLayer_legacy.promote();
Robert Carr0d480722017-01-10 16:42:54 -0800779 if (barrierLayer == nullptr) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700780 ALOGE("[%s] Unable to promote barrier Layer.", getDebugName());
Dan Stoza7dde5992015-05-22 09:51:44 -0700781 // If we can't promote the layer we are intended to wait on,
782 // then it is expired or otherwise invalid. Allow this transaction
783 // to be applied as per normal (no synchronization).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800784 mCurrentState.barrierLayer_legacy = nullptr;
Pablo Ceballos3bddd5b2015-11-19 14:39:14 -0800785 } else {
chaviw43cb3cb2019-05-31 15:23:41 -0700786 auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.frameNumber_legacy, this);
Robert Carr0d480722017-01-10 16:42:54 -0800787 if (barrierLayer->addSyncPoint(syncPoint)) {
Alec Mourie60041e2019-06-14 18:59:51 -0700788 std::stringstream ss;
789 ss << "Adding sync point " << mCurrentState.frameNumber_legacy;
790 ATRACE_NAME(ss.str().c_str());
Dan Stozacac35382016-01-27 12:21:06 -0800791 mRemoteSyncPoints.push_back(std::move(syncPoint));
792 } else {
793 // We already missed the frame we're supposed to synchronize
794 // on, so go ahead and apply the state update
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800795 mCurrentState.barrierLayer_legacy = nullptr;
Dan Stozacac35382016-01-27 12:21:06 -0800796 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700797 }
798
Dan Stoza7dde5992015-05-22 09:51:44 -0700799 // Wake us up to check if the frame has been received
800 setTransactionFlags(eTransactionNeeded);
Dan Stozaf5702ff2016-11-02 16:27:47 -0700801 mFlinger->setTransactionFlags(eTraversalNeeded);
Dan Stoza7dde5992015-05-22 09:51:44 -0700802 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800803 mPendingStates.push_back(mCurrentState);
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700804 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700805}
806
Pablo Ceballos05289c22016-04-14 15:49:55 -0700807void Layer::popPendingState(State* stateToCommit) {
Alec Mourie60041e2019-06-14 18:59:51 -0700808 ATRACE_CALL();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800809 *stateToCommit = mPendingStates[0];
Dan Stoza7dde5992015-05-22 09:51:44 -0700810
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800811 mPendingStates.removeAt(0);
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700812 ATRACE_INT(mTransactionName.c_str(), mPendingStates.size());
Dan Stoza7dde5992015-05-22 09:51:44 -0700813}
814
Pablo Ceballos05289c22016-04-14 15:49:55 -0700815bool Layer::applyPendingStates(State* stateToCommit) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700816 bool stateUpdateAvailable = false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800817 while (!mPendingStates.empty()) {
818 if (mPendingStates[0].barrierLayer_legacy != nullptr) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700819 if (mRemoteSyncPoints.empty()) {
820 // If we don't have a sync point for this, apply it anyway. It
821 // will be visually wrong, but it should keep us from getting
822 // into too much trouble.
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700823 ALOGE("[%s] No local sync point found", getDebugName());
Pablo Ceballos05289c22016-04-14 15:49:55 -0700824 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700825 stateUpdateAvailable = true;
826 continue;
827 }
828
Marissa Wallf58c14b2018-07-24 10:50:43 -0700829 if (mRemoteSyncPoints.front()->getFrameNumber() !=
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800830 mPendingStates[0].frameNumber_legacy) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700831 ALOGE("[%s] Unexpected sync point frame number found", getDebugName());
Dan Stozacac35382016-01-27 12:21:06 -0800832
833 // Signal our end of the sync point and then dispose of it
834 mRemoteSyncPoints.front()->setTransactionApplied();
835 mRemoteSyncPoints.pop_front();
836 continue;
837 }
838
Dan Stoza7dde5992015-05-22 09:51:44 -0700839 if (mRemoteSyncPoints.front()->frameIsAvailable()) {
Alec Mourie60041e2019-06-14 18:59:51 -0700840 ATRACE_NAME("frameIsAvailable");
Dan Stoza7dde5992015-05-22 09:51:44 -0700841 // Apply the state update
Pablo Ceballos05289c22016-04-14 15:49:55 -0700842 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700843 stateUpdateAvailable = true;
844
845 // Signal our end of the sync point and then dispose of it
846 mRemoteSyncPoints.front()->setTransactionApplied();
847 mRemoteSyncPoints.pop_front();
Dan Stoza792e5292016-02-11 11:43:58 -0800848 } else {
Alec Mourie60041e2019-06-14 18:59:51 -0700849 ATRACE_NAME("!frameIsAvailable");
Dan Stoza792e5292016-02-11 11:43:58 -0800850 break;
Dan Stoza7dde5992015-05-22 09:51:44 -0700851 }
Dan Stoza7dde5992015-05-22 09:51:44 -0700852 } else {
Pablo Ceballos05289c22016-04-14 15:49:55 -0700853 popPendingState(stateToCommit);
Dan Stoza7dde5992015-05-22 09:51:44 -0700854 stateUpdateAvailable = true;
855 }
856 }
857
858 // If we still have pending updates, wake SurfaceFlinger back up and point
859 // it at this layer so we can process them
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800860 if (!mPendingStates.empty()) {
Dan Stoza7dde5992015-05-22 09:51:44 -0700861 setTransactionFlags(eTransactionNeeded);
862 mFlinger->setTransactionFlags(eTraversalNeeded);
863 }
864
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800865 mCurrentState.modified = false;
Dan Stoza7dde5992015-05-22 09:51:44 -0700866 return stateUpdateAvailable;
867}
868
Marissa Wall61c58622018-07-18 10:12:20 -0700869uint32_t Layer::doTransactionResize(uint32_t flags, State* stateToCommit) {
Alec Mourib416efd2018-09-06 21:01:59 +0000870 const State& s(getDrawingState());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800871
Marissa Wall61c58622018-07-18 10:12:20 -0700872 const bool sizeChanged = (stateToCommit->requested_legacy.w != s.requested_legacy.w) ||
873 (stateToCommit->requested_legacy.h != s.requested_legacy.h);
Mathias Agopiana138f892010-05-21 17:24:35 -0700874
David Sodmaneb085e02017-10-05 18:49:04 -0700875 if (sizeChanged) {
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700876 // the size changed, we need to ask our client to request a new buffer
Steve Block9d453682011-12-20 16:23:08 +0000877 ALOGD_IF(DEBUG_RESIZE,
David Sodman41fdfc92017-11-06 16:09:56 -0800878 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
879 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
880 " requested={ wh={%4u,%4u} }}\n"
881 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
882 " requested={ wh={%4u,%4u} }}\n",
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700883 this, getName().c_str(), getBufferTransform(), getEffectiveScalingMode(),
Marissa Wall61c58622018-07-18 10:12:20 -0700884 stateToCommit->active_legacy.w, stateToCommit->active_legacy.h,
885 stateToCommit->crop_legacy.left, stateToCommit->crop_legacy.top,
886 stateToCommit->crop_legacy.right, stateToCommit->crop_legacy.bottom,
887 stateToCommit->crop_legacy.getWidth(), stateToCommit->crop_legacy.getHeight(),
888 stateToCommit->requested_legacy.w, stateToCommit->requested_legacy.h,
Marissa Wallf58c14b2018-07-24 10:50:43 -0700889 s.active_legacy.w, s.active_legacy.h, s.crop_legacy.left, s.crop_legacy.top,
890 s.crop_legacy.right, s.crop_legacy.bottom, s.crop_legacy.getWidth(),
891 s.crop_legacy.getHeight(), s.requested_legacy.w, s.requested_legacy.h);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800892 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700893
Robert Carre392b552017-09-19 12:16:05 -0700894 // Don't let Layer::doTransaction update the drawing state
895 // if we have a pending resize, unless we are in fixed-size mode.
896 // the drawing state will be updated only once we receive a buffer
897 // with the correct size.
898 //
899 // In particular, we want to make sure the clip (which is part
900 // of the geometry state) is latched together with the size but is
901 // latched immediately when no resizing is involved.
902 //
903 // If a sideband stream is attached, however, we want to skip this
904 // optimization so that transactions aren't missed when a buffer
905 // never arrives
906 //
907 // In the case that we don't have a buffer we ignore other factors
908 // and avoid entering the resizePending state. At a high level the
909 // resizePending state is to avoid applying the state of the new buffer
910 // to the old buffer. However in the state where we don't have an old buffer
911 // there is no such concern but we may still be being used as a parent layer.
Marissa Wall61c58622018-07-18 10:12:20 -0700912 const bool resizePending =
913 ((stateToCommit->requested_legacy.w != stateToCommit->active_legacy.w) ||
914 (stateToCommit->requested_legacy.h != stateToCommit->active_legacy.h)) &&
chaviwd62d3062019-09-04 14:48:02 -0700915 (getBuffer() != nullptr);
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700916 if (!isFixedSize()) {
Lloyd Pique0b785d82018-12-04 17:25:27 -0800917 if (resizePending && mSidebandStream == nullptr) {
Mathias Agopian0cd545f2012-06-07 14:18:55 -0700918 flags |= eDontUpdateGeometryState;
919 }
920 }
921
Robert Carr7bf247e2017-05-18 14:02:49 -0700922 // Here we apply various requested geometry states, depending on our
923 // latching configuration. See Layer.h for a detailed discussion of
924 // how geometry latching is controlled.
925 if (!(flags & eDontUpdateGeometryState)) {
Alec Mourib416efd2018-09-06 21:01:59 +0000926 State& editCurrentState(getCurrentState());
Robert Carr7bf247e2017-05-18 14:02:49 -0700927
Robert Carr7bf247e2017-05-18 14:02:49 -0700928 // There is an awkward asymmetry in the handling of the crop states in the position
929 // states, as can be seen below. Largely this arises from position and transform
930 // being stored in the same data structure while having different latching rules.
931 // b/38182305
932 //
Marissa Wall61c58622018-07-18 10:12:20 -0700933 // Careful that "stateToCommit" and editCurrentState may not begin as equivalent due to
Robert Carr7bf247e2017-05-18 14:02:49 -0700934 // applyPendingStates in the presence of deferred transactions.
chaviw214c89d2019-09-04 16:03:53 -0700935 editCurrentState.active_legacy = editCurrentState.requested_legacy;
936 stateToCommit->active_legacy = stateToCommit->requested_legacy;
Mathias Agopian13127d82013-03-05 17:47:11 -0800937 }
938
Marissa Wall61c58622018-07-18 10:12:20 -0700939 return flags;
940}
941
942uint32_t Layer::doTransaction(uint32_t flags) {
943 ATRACE_CALL();
944
chaviw5aedec92018-10-22 10:40:38 -0700945 if (mLayerDetached) {
Robert Carr321e83c2019-08-19 15:49:30 -0700946 // Ensure BLAST buffer callbacks are processed.
947 // detachChildren and mLayerDetached were implemented to avoid geometry updates
948 // to layers in the cases of animation. For BufferQueue layers buffers are still
949 // consumed as normal. This is useful as otherwise the client could get hung
950 // inevitably waiting on a buffer to return. We recreate this semantic for BufferQueue
951 // even though it is a little consistent. detachChildren is shortly slated for removal
952 // by the hierarchy mirroring work so we don't need to worry about it too much.
Valerie Hau7618b232020-01-09 16:03:08 -0800953 forceSendCallbacks();
Robert Carr321e83c2019-08-19 15:49:30 -0700954 mCurrentState.callbackHandles = {};
Robert Carr7f2ed8b2019-02-07 14:45:11 -0800955 return flags;
956 }
957
958 if (mChildrenChanged) {
959 flags |= eVisibleRegion;
960 mChildrenChanged = false;
chaviw5aedec92018-10-22 10:40:38 -0700961 }
962
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800963 pushPendingState();
Alec Mourib416efd2018-09-06 21:01:59 +0000964 State c = getCurrentState();
Marissa Wall61c58622018-07-18 10:12:20 -0700965 if (!applyPendingStates(&c)) {
Robert Carr7f2ed8b2019-02-07 14:45:11 -0800966 return flags;
Marissa Wall61c58622018-07-18 10:12:20 -0700967 }
968
969 flags = doTransactionResize(flags, &c);
970
Alec Mourib416efd2018-09-06 21:01:59 +0000971 const State& s(getDrawingState());
Marissa Wall61c58622018-07-18 10:12:20 -0700972
973 if (getActiveGeometry(c) != getActiveGeometry(s)) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800974 // invalidate and recompute the visible regions if needed
975 flags |= Layer::eVisibleRegion;
976 }
977
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700978 if (c.sequence != s.sequence) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800979 // invalidate and recompute the visible regions if needed
980 flags |= eVisibleRegion;
981 this->contentDirty = true;
982
983 // we may use linear filtering, if the matrix scales us
Marissa Wall61c58622018-07-18 10:12:20 -0700984 const uint8_t type = getActiveTransform(c).getType();
Peiyong Linefefaac2018-08-17 12:27:51 -0700985 mNeedsFiltering = (!getActiveTransform(c).preserveRects() || type >= ui::Transform::SCALE);
Mathias Agopian13127d82013-03-05 17:47:11 -0800986 }
987
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800988 if (mCurrentState.inputInfoChanged) {
Robert Carr720e5062018-07-30 17:45:14 -0700989 flags |= eInputInfoChanged;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800990 mCurrentState.inputInfoChanged = false;
Robert Carr720e5062018-07-30 17:45:14 -0700991 }
992
Mathias Agopian13127d82013-03-05 17:47:11 -0800993 // Commit the transaction
Pablo Ceballos05289c22016-04-14 15:49:55 -0700994 commitTransaction(c);
Vishnu Nair8406fd72019-07-30 11:29:31 -0700995 mPendingStatesSnapshot = mPendingStates;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800996 mCurrentState.callbackHandles = {};
Mathias Agopian13127d82013-03-05 17:47:11 -0800997 return flags;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800998}
999
Pablo Ceballos05289c22016-04-14 15:49:55 -07001000void Layer::commitTransaction(const State& stateToCommit) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001001 mDrawingState = stateToCommit;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001002}
1003
Mathias Agopian13127d82013-03-05 17:47:11 -08001004uint32_t Layer::getTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001005 return mTransactionFlags.fetch_and(~flags) & flags;
Mathias Agopian13127d82013-03-05 17:47:11 -08001006}
1007
1008uint32_t Layer::setTransactionFlags(uint32_t flags) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001009 return mTransactionFlags.fetch_or(flags);
Mathias Agopian13127d82013-03-05 17:47:11 -08001010}
1011
chaviw214c89d2019-09-04 16:03:53 -07001012bool Layer::setPosition(float x, float y) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001013 if (mCurrentState.requested_legacy.transform.tx() == x &&
1014 mCurrentState.requested_legacy.transform.ty() == y)
Mathias Agopian13127d82013-03-05 17:47:11 -08001015 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001016 mCurrentState.sequence++;
Robert Carr69663fb2016-03-27 19:59:19 -07001017
1018 // We update the requested and active position simultaneously because
1019 // we want to apply the position portion of the transform matrix immediately,
1020 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001021 mCurrentState.requested_legacy.transform.set(x, y);
chaviw214c89d2019-09-04 16:03:53 -07001022 // Here we directly update the active state
1023 // unlike other setters, because we store it within
1024 // the transform, but use different latching rules.
1025 // b/38182305
1026 mCurrentState.active_legacy.transform.set(x, y);
Robert Carr69663fb2016-03-27 19:59:19 -07001027
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001028 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001029 setTransactionFlags(eTransactionNeeded);
1030 return true;
1031}
Robert Carr82364e32016-05-15 11:27:47 -07001032
Robert Carr1f0a16a2016-10-24 16:27:39 -07001033bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
1034 ssize_t idx = mCurrentChildren.indexOf(childLayer);
1035 if (idx < 0) {
1036 return false;
1037 }
1038 if (childLayer->setLayer(z)) {
1039 mCurrentChildren.removeAt(idx);
1040 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -08001041 return true;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001042 }
Robert Carr503d2bd2017-12-04 15:49:47 -08001043 return false;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001044}
1045
Robert Carr503c7042017-09-27 15:06:08 -07001046bool Layer::setChildRelativeLayer(const sp<Layer>& childLayer,
1047 const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
1048 ssize_t idx = mCurrentChildren.indexOf(childLayer);
1049 if (idx < 0) {
1050 return false;
1051 }
1052 if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) {
1053 mCurrentChildren.removeAt(idx);
1054 mCurrentChildren.add(childLayer);
Robert Carr503d2bd2017-12-04 15:49:47 -08001055 return true;
Robert Carr503c7042017-09-27 15:06:08 -07001056 }
Robert Carr503d2bd2017-12-04 15:49:47 -08001057 return false;
Robert Carr503c7042017-09-27 15:06:08 -07001058}
1059
Robert Carrae060832016-11-28 10:51:00 -08001060bool Layer::setLayer(int32_t z) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001061 if (mCurrentState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
1062 mCurrentState.sequence++;
1063 mCurrentState.z = z;
1064 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -07001065
1066 // Discard all relative layering.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001067 if (mCurrentState.zOrderRelativeOf != nullptr) {
1068 sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
Robert Carrdb66e622017-04-10 16:55:57 -07001069 if (strongRelative != nullptr) {
1070 strongRelative->removeZOrderRelative(this);
1071 }
chaviw606e5cf2019-03-01 10:12:10 -08001072 setZOrderRelativeOf(nullptr);
Robert Carrdb66e622017-04-10 16:55:57 -07001073 }
Mathias Agopian13127d82013-03-05 17:47:11 -08001074 setTransactionFlags(eTransactionNeeded);
1075 return true;
1076}
Robert Carr1f0a16a2016-10-24 16:27:39 -07001077
Robert Carrdb66e622017-04-10 16:55:57 -07001078void Layer::removeZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001079 mCurrentState.zOrderRelatives.remove(relative);
1080 mCurrentState.sequence++;
1081 mCurrentState.modified = true;
Robert Carrdb66e622017-04-10 16:55:57 -07001082 setTransactionFlags(eTransactionNeeded);
1083}
1084
1085void Layer::addZOrderRelative(const wp<Layer>& relative) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001086 mCurrentState.zOrderRelatives.add(relative);
1087 mCurrentState.modified = true;
1088 mCurrentState.sequence++;
Robert Carrdb66e622017-04-10 16:55:57 -07001089 setTransactionFlags(eTransactionNeeded);
1090}
1091
chaviw606e5cf2019-03-01 10:12:10 -08001092void Layer::setZOrderRelativeOf(const wp<Layer>& relativeOf) {
1093 mCurrentState.zOrderRelativeOf = relativeOf;
1094 mCurrentState.sequence++;
1095 mCurrentState.modified = true;
chaviwbdb8b802019-10-14 09:17:12 -07001096 mCurrentState.isRelativeOf = relativeOf != nullptr;
1097
chaviw606e5cf2019-03-01 10:12:10 -08001098 setTransactionFlags(eTransactionNeeded);
1099}
1100
Robert Carr503d2bd2017-12-04 15:49:47 -08001101bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
Robert Carrdb66e622017-04-10 16:55:57 -07001102 sp<Handle> handle = static_cast<Handle*>(relativeToHandle.get());
1103 if (handle == nullptr) {
1104 return false;
1105 }
1106 sp<Layer> relative = handle->owner.promote();
1107 if (relative == nullptr) {
1108 return false;
1109 }
1110
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001111 if (mCurrentState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) &&
1112 mCurrentState.zOrderRelativeOf == relative) {
Robert Carr503d2bd2017-12-04 15:49:47 -08001113 return false;
1114 }
1115
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001116 mCurrentState.sequence++;
1117 mCurrentState.modified = true;
1118 mCurrentState.z = relativeZ;
Robert Carrdb66e622017-04-10 16:55:57 -07001119
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001120 auto oldZOrderRelativeOf = mCurrentState.zOrderRelativeOf.promote();
chaviw9ab4bd12017-11-03 13:11:00 -07001121 if (oldZOrderRelativeOf != nullptr) {
1122 oldZOrderRelativeOf->removeZOrderRelative(this);
1123 }
chaviw606e5cf2019-03-01 10:12:10 -08001124 setZOrderRelativeOf(relative);
Robert Carrdb66e622017-04-10 16:55:57 -07001125 relative->addZOrderRelative(this);
1126
1127 setTransactionFlags(eTransactionNeeded);
1128
1129 return true;
1130}
1131
Mathias Agopian13127d82013-03-05 17:47:11 -08001132bool Layer::setSize(uint32_t w, uint32_t h) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001133 if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h)
Marissa Wallf58c14b2018-07-24 10:50:43 -07001134 return false;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001135 mCurrentState.requested_legacy.w = w;
1136 mCurrentState.requested_legacy.h = h;
1137 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001138 setTransactionFlags(eTransactionNeeded);
Vishnu Naird01c4432018-08-13 10:38:47 -07001139
1140 // record the new size, from this point on, when the client request
1141 // a buffer, it'll get the new size.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001142 setDefaultBufferSize(mCurrentState.requested_legacy.w, mCurrentState.requested_legacy.h);
Mathias Agopian13127d82013-03-05 17:47:11 -08001143 return true;
1144}
Dan Stoza9e56aa02015-11-02 13:00:03 -08001145bool Layer::setAlpha(float alpha) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001146 if (mCurrentState.color.a == alpha) return false;
1147 mCurrentState.sequence++;
1148 mCurrentState.color.a = alpha;
1149 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001150 setTransactionFlags(eTransactionNeeded);
1151 return true;
1152}
chaviw13fdc492017-06-27 12:40:18 -07001153
Valerie Haudd0b7572019-01-29 14:59:27 -08001154bool Layer::setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace) {
1155 if (!mCurrentState.bgColorLayer && alpha == 0) {
chaviw13fdc492017-06-27 12:40:18 -07001156 return false;
Valerie Hauaa194562019-02-05 16:21:38 -08001157 }
1158 mCurrentState.sequence++;
1159 mCurrentState.modified = true;
1160 setTransactionFlags(eTransactionNeeded);
1161
1162 if (!mCurrentState.bgColorLayer && alpha != 0) {
Valerie Haudd0b7572019-01-29 14:59:27 -08001163 // create background color layer if one does not yet exist
Vishnu Nairfa247b12020-02-11 08:58:26 -08001164 uint32_t flags = ISurfaceComposerClient::eFXSurfaceEffect;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001165 std::string name = mName + "BackgroundColorLayer";
Vishnu Nairfa247b12020-02-11 08:58:26 -08001166 mCurrentState.bgColorLayer = mFlinger->getFactory().createEffectLayer(
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001167 LayerCreationArgs(mFlinger.get(), nullptr, std::move(name), 0, 0, flags,
1168 LayerMetadata()));
chaviw13fdc492017-06-27 12:40:18 -07001169
Valerie Haudd0b7572019-01-29 14:59:27 -08001170 // add to child list
1171 addChild(mCurrentState.bgColorLayer);
1172 mFlinger->mLayersAdded = true;
1173 // set up SF to handle added color layer
1174 if (isRemovedFromCurrentState()) {
1175 mCurrentState.bgColorLayer->onRemovedFromCurrentState();
1176 }
1177 mFlinger->setTransactionFlags(eTransactionNeeded);
1178 } else if (mCurrentState.bgColorLayer && alpha == 0) {
1179 mCurrentState.bgColorLayer->reparent(nullptr);
1180 mCurrentState.bgColorLayer = nullptr;
1181 return true;
1182 }
1183
1184 mCurrentState.bgColorLayer->setColor(color);
1185 mCurrentState.bgColorLayer->setLayer(std::numeric_limits<int32_t>::min());
1186 mCurrentState.bgColorLayer->setAlpha(alpha);
1187 mCurrentState.bgColorLayer->setDataspace(dataspace);
1188
chaviw13fdc492017-06-27 12:40:18 -07001189 return true;
1190}
1191
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001192bool Layer::setCornerRadius(float cornerRadius) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001193 if (mCurrentState.cornerRadius == cornerRadius) return false;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001194
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001195 mCurrentState.sequence++;
1196 mCurrentState.cornerRadius = cornerRadius;
1197 mCurrentState.modified = true;
Lucas Dupin1b6531c2018-07-05 17:18:21 -07001198 setTransactionFlags(eTransactionNeeded);
1199 return true;
1200}
1201
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08001202bool Layer::setBackgroundBlurRadius(int backgroundBlurRadius) {
1203 if (mCurrentState.backgroundBlurRadius == backgroundBlurRadius) return false;
1204
1205 mCurrentState.sequence++;
1206 mCurrentState.backgroundBlurRadius = backgroundBlurRadius;
1207 mCurrentState.modified = true;
1208 setTransactionFlags(eTransactionNeeded);
1209 return true;
1210}
1211
Robert Carrd4ae7f32018-06-07 16:10:57 -07001212bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix,
1213 bool allowNonRectPreservingTransforms) {
Peiyong Linefefaac2018-08-17 12:27:51 -07001214 ui::Transform t;
Robert Carrd4ae7f32018-06-07 16:10:57 -07001215 t.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
1216
1217 if (!allowNonRectPreservingTransforms && !t.preserveRects()) {
1218 ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored");
1219 return false;
1220 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001221 mCurrentState.sequence++;
1222 mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
1223 matrix.dsdy);
1224 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001225 setTransactionFlags(eTransactionNeeded);
1226 return true;
1227}
Marissa Wall61c58622018-07-18 10:12:20 -07001228
Mathias Agopian13127d82013-03-05 17:47:11 -08001229bool Layer::setTransparentRegionHint(const Region& transparent) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001230 mCurrentState.requestedTransparentRegion_legacy = transparent;
1231 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001232 setTransactionFlags(eTransactionNeeded);
1233 return true;
1234}
Ana Krulecc84d09b2019-11-02 23:10:29 +01001235
Mathias Agopian13127d82013-03-05 17:47:11 -08001236bool Layer::setFlags(uint8_t flags, uint8_t mask) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001237 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
1238 if (mCurrentState.flags == newFlags) return false;
1239 mCurrentState.sequence++;
1240 mCurrentState.flags = newFlags;
1241 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001242 setTransactionFlags(eTransactionNeeded);
1243 return true;
1244}
Robert Carr99e27f02016-06-16 15:18:02 -07001245
chaviw214c89d2019-09-04 16:03:53 -07001246bool Layer::setCrop_legacy(const Rect& crop) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001247 if (mCurrentState.requestedCrop_legacy == crop) return false;
1248 mCurrentState.sequence++;
1249 mCurrentState.requestedCrop_legacy = crop;
chaviw214c89d2019-09-04 16:03:53 -07001250 mCurrentState.crop_legacy = crop;
Robert Carr7bf247e2017-05-18 14:02:49 -07001251
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001252 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001253 setTransactionFlags(eTransactionNeeded);
1254 return true;
1255}
Robert Carr8d5227b2017-03-16 15:41:03 -07001256
Robert Carrc3574f72016-03-24 12:19:32 -07001257bool Layer::setOverrideScalingMode(int32_t scalingMode) {
David Sodman41fdfc92017-11-06 16:09:56 -08001258 if (scalingMode == mOverrideScalingMode) return false;
Robert Carrc3574f72016-03-24 12:19:32 -07001259 mOverrideScalingMode = scalingMode;
Robert Carr82364e32016-05-15 11:27:47 -07001260 setTransactionFlags(eTransactionNeeded);
Robert Carrc3574f72016-03-24 12:19:32 -07001261 return true;
1262}
1263
Evan Roskyef876c92019-01-25 17:46:06 -08001264bool Layer::setMetadata(const LayerMetadata& data) {
1265 if (!mCurrentState.metadata.merge(data, true /* eraseEmpty */)) return false;
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001266 mCurrentState.sequence++;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001267 mCurrentState.modified = true;
David Sodman41fdfc92017-11-06 16:09:56 -08001268 setTransactionFlags(eTransactionNeeded);
Evan Rosky1f6d6d52018-12-06 10:47:26 -08001269 return true;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -05001270}
1271
Mathias Agopian13127d82013-03-05 17:47:11 -08001272bool Layer::setLayerStack(uint32_t layerStack) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001273 if (mCurrentState.layerStack == layerStack) return false;
1274 mCurrentState.sequence++;
1275 mCurrentState.layerStack = layerStack;
1276 mCurrentState.modified = true;
Mathias Agopian13127d82013-03-05 17:47:11 -08001277 setTransactionFlags(eTransactionNeeded);
1278 return true;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001279}
1280
Peiyong Linc502cb72019-03-01 15:00:23 -08001281bool Layer::setColorSpaceAgnostic(const bool agnostic) {
1282 if (mCurrentState.colorSpaceAgnostic == agnostic) {
1283 return false;
1284 }
1285 mCurrentState.sequence++;
1286 mCurrentState.colorSpaceAgnostic = agnostic;
1287 mCurrentState.modified = true;
1288 setTransactionFlags(eTransactionNeeded);
1289 return true;
1290}
1291
Ana Krulecc84d09b2019-11-02 23:10:29 +01001292bool Layer::setFrameRateSelectionPriority(int32_t priority) {
1293 if (mCurrentState.frameRateSelectionPriority == priority) return false;
1294 mCurrentState.frameRateSelectionPriority = priority;
1295 mCurrentState.sequence++;
1296 mCurrentState.modified = true;
1297 setTransactionFlags(eTransactionNeeded);
1298 return true;
1299}
1300
1301int32_t Layer::getFrameRateSelectionPriority() const {
1302 // Check if layer has priority set.
1303 if (mDrawingState.frameRateSelectionPriority != PRIORITY_UNSET) {
1304 return mDrawingState.frameRateSelectionPriority;
1305 }
1306 // If not, search whether its parents have it set.
1307 sp<Layer> parent = getParent();
1308 if (parent != nullptr) {
1309 return parent->getFrameRateSelectionPriority();
1310 }
1311
1312 return Layer::PRIORITY_UNSET;
1313}
1314
Robert Carr1f0a16a2016-10-24 16:27:39 -07001315uint32_t Layer::getLayerStack() const {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001316 auto p = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001317 if (p == nullptr) {
1318 return getDrawingState().layerStack;
1319 }
1320 return p->getLayerStack();
1321}
1322
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001323bool Layer::setShadowRadius(float shadowRadius) {
1324 if (mCurrentState.shadowRadius == shadowRadius) {
1325 return false;
1326 }
1327
1328 mCurrentState.sequence++;
1329 mCurrentState.shadowRadius = shadowRadius;
1330 mCurrentState.modified = true;
1331 setTransactionFlags(eTransactionNeeded);
1332 return true;
1333}
1334
Ady Abraham60e42ea2020-03-09 19:17:31 -07001335void Layer::updateTreeHasFrameRateVote() {
1336 const auto traverseTree = [&](const LayerVector::Visitor& visitor) {
1337 auto parent = getParent();
1338 while (parent) {
1339 visitor(parent.get());
1340 parent = parent->getParent();
1341 }
1342
1343 traverse(LayerVector::StateSet::Current, visitor);
1344 };
1345
1346 // update parents and children about the vote
1347 // First traverse the tree and count how many layers has votes
1348 int layersWithVote = 0;
1349 traverseTree([&layersWithVote](Layer* layer) {
1350 if (layer->mCurrentState.frameRate.rate > 0 ||
1351 layer->mCurrentState.frameRate.type == FrameRateCompatibility::NoVote) {
1352 layersWithVote++;
1353 }
1354 });
1355
1356 // Now update the other layers
1357 bool transactionNeeded = false;
1358 traverseTree([layersWithVote, &transactionNeeded](Layer* layer) {
1359 if (layer->mCurrentState.treeHasFrameRateVote != layersWithVote > 0) {
1360 layer->mCurrentState.sequence++;
1361 layer->mCurrentState.treeHasFrameRateVote = layersWithVote > 0;
1362 layer->mCurrentState.modified = true;
1363 layer->setTransactionFlags(eTransactionNeeded);
1364 transactionNeeded = true;
1365 }
1366 });
1367
1368 if (transactionNeeded) {
1369 mFlinger->setTransactionFlags(eTraversalNeeded);
1370 }
1371}
1372
Ady Abraham71c437d2020-01-31 15:56:57 -08001373bool Layer::setFrameRate(FrameRate frameRate) {
Ana Krulec3803b8d2020-02-03 16:35:46 -08001374 if (!mFlinger->useFrameRateApi) {
1375 return false;
1376 }
Steven Thomas3172e202020-01-06 19:25:30 -08001377 if (mCurrentState.frameRate == frameRate) {
1378 return false;
1379 }
1380
1381 mCurrentState.sequence++;
1382 mCurrentState.frameRate = frameRate;
1383 mCurrentState.modified = true;
Ady Abraham60e42ea2020-03-09 19:17:31 -07001384
1385 updateTreeHasFrameRateVote();
1386
Steven Thomas3172e202020-01-06 19:25:30 -08001387 setTransactionFlags(eTransactionNeeded);
1388 return true;
1389}
1390
Ady Abraham60e42ea2020-03-09 19:17:31 -07001391Layer::FrameRate Layer::getFrameRateForLayerTree() const {
1392 const auto frameRate = getDrawingState().frameRate;
1393 if (frameRate.rate > 0 || frameRate.type == FrameRateCompatibility::NoVote) {
1394 return frameRate;
1395 }
1396
1397 // This layer doesn't have a frame rate. If one of its ancestors or successors
1398 // have a vote, return a NoVote for ancestors/successors to set the vote
1399 if (getDrawingState().treeHasFrameRateVote) {
1400 return {0, FrameRateCompatibility::NoVote};
1401 }
1402
1403 return frameRate;
Steven Thomas3172e202020-01-06 19:25:30 -08001404}
1405
Marissa Wallf58c14b2018-07-24 10:50:43 -07001406void Layer::deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
Alec Mourie60041e2019-06-14 18:59:51 -07001407 ATRACE_CALL();
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001408 mCurrentState.barrierLayer_legacy = barrierLayer;
1409 mCurrentState.frameNumber_legacy = frameNumber;
Dan Stoza7dde5992015-05-22 09:51:44 -07001410 // We don't set eTransactionNeeded, because just receiving a deferral
1411 // request without any other state updates shouldn't actually induce a delay
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001412 mCurrentState.modified = true;
1413 pushPendingState();
1414 mCurrentState.barrierLayer_legacy = nullptr;
1415 mCurrentState.frameNumber_legacy = 0;
1416 mCurrentState.modified = false;
Robert Carr0d480722017-01-10 16:42:54 -08001417}
1418
Marissa Wallf58c14b2018-07-24 10:50:43 -07001419void Layer::deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
Robert Carr0d480722017-01-10 16:42:54 -08001420 sp<Handle> handle = static_cast<Handle*>(barrierHandle.get());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001421 deferTransactionUntil_legacy(handle->owner.promote(), frameNumber);
Dan Stoza7dde5992015-05-22 09:51:44 -07001422}
1423
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001424// ----------------------------------------------------------------------------
1425// pageflip handling...
1426// ----------------------------------------------------------------------------
1427
Robert Carr1f0a16a2016-10-24 16:27:39 -07001428bool Layer::isHiddenByPolicy() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001429 const State& s(mDrawingState);
Chia-I Wue41dbe62017-06-13 14:10:56 -07001430 const auto& parent = mDrawingParent.promote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001431 if (parent != nullptr && parent->isHiddenByPolicy()) {
1432 return true;
1433 }
Robert Carr1c5481e2019-07-01 14:42:27 -07001434 if (usingRelativeZ(LayerVector::StateSet::Drawing)) {
1435 auto zOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote();
1436 if (zOrderRelativeOf != nullptr) {
1437 if (zOrderRelativeOf->isHiddenByPolicy()) {
1438 return true;
1439 }
1440 }
1441 }
Robert Carr1f0a16a2016-10-24 16:27:39 -07001442 return s.flags & layer_state_t::eLayerHidden;
1443}
1444
David Sodman41fdfc92017-11-06 16:09:56 -08001445uint32_t Layer::getEffectiveUsage(uint32_t usage) const {
Mathias Agopiana67932f2011-04-20 14:20:59 -07001446 // TODO: should we do something special if mSecure is set?
1447 if (mProtectedByApp) {
1448 // need a hardware-protected path to external video sink
1449 usage |= GraphicBuffer::USAGE_PROTECTED;
Jamie Gennis54cc83e2010-11-02 11:51:32 -07001450 }
Riley Andrews03414a12014-07-01 14:22:59 -07001451 if (mPotentialCursor) {
1452 usage |= GraphicBuffer::USAGE_CURSOR;
1453 }
Jamie Gennis3599bf22011-08-10 11:48:07 -07001454 usage |= GraphicBuffer::USAGE_HW_COMPOSER;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001455 return usage;
Mathias Agopianb5b7f262010-05-07 15:58:44 -07001456}
1457
Dominik Laskowskia2edf612018-06-01 13:15:16 -07001458void Layer::updateTransformHint(const sp<const DisplayDevice>& display) const {
Mathias Agopiana4583642011-08-23 18:03:18 -07001459 uint32_t orientation = 0;
Vishnu Nair5eb3f062019-04-08 08:21:03 -07001460 // Disable setting transform hint if the debug flag is set.
1461 if (!mFlinger->mDebugDisableTransformHint) {
Mathias Agopian84300952012-11-21 16:02:13 -08001462 // The transform hint is used to improve performance, but we can
1463 // only have a single transform hint, it cannot
Mathias Agopian4fec8732012-06-29 14:12:52 -07001464 // apply to all displays.
Peiyong Linefefaac2018-08-17 12:27:51 -07001465 const ui::Transform& planeTransform = display->getTransform();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001466 orientation = planeTransform.getOrientation();
Peiyong Linefefaac2018-08-17 12:27:51 -07001467 if (orientation & ui::Transform::ROT_INVALID) {
Mathias Agopiana4583642011-08-23 18:03:18 -07001468 orientation = 0;
1469 }
1470 }
David Sodmaneb085e02017-10-05 18:49:04 -07001471 setTransformHint(orientation);
Mathias Agopiana4583642011-08-23 18:03:18 -07001472}
1473
Mathias Agopian13127d82013-03-05 17:47:11 -08001474// ----------------------------------------------------------------------------
1475// debugging
1476// ----------------------------------------------------------------------------
1477
Marissa Wall61c58622018-07-18 10:12:20 -07001478// TODO(marissaw): add new layer state info to layer debugging
Kalle Raitaa099a242017-01-11 11:17:29 -08001479LayerDebugInfo Layer::getLayerDebugInfo() const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001480 using namespace std::string_literals;
1481
Kalle Raitaa099a242017-01-11 11:17:29 -08001482 LayerDebugInfo info;
Alec Mourib416efd2018-09-06 21:01:59 +00001483 const State& ds = getDrawingState();
Kalle Raitaa099a242017-01-11 11:17:29 -08001484 info.mName = getName();
chaviw1acbec72017-07-27 15:28:26 -07001485 sp<Layer> parent = getParent();
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001486 info.mParentName = parent ? parent->getName() : "none"s;
chaviw8a01fa42019-08-19 12:39:31 -07001487 info.mType = getType();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001488 info.mTransparentRegion = ds.activeTransparentRegion_legacy;
Lloyd Piquea2468662019-03-07 21:31:06 -08001489
1490 info.mVisibleRegion = debugGetVisibleRegionOnDefaultDisplay();
Kalle Raitaa099a242017-01-11 11:17:29 -08001491 info.mSurfaceDamageRegion = surfaceDamageRegion;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001492 info.mLayerStack = getLayerStack();
Marissa Wallf58c14b2018-07-24 10:50:43 -07001493 info.mX = ds.active_legacy.transform.tx();
1494 info.mY = ds.active_legacy.transform.ty();
Kalle Raitaa099a242017-01-11 11:17:29 -08001495 info.mZ = ds.z;
Marissa Wallf58c14b2018-07-24 10:50:43 -07001496 info.mWidth = ds.active_legacy.w;
1497 info.mHeight = ds.active_legacy.h;
1498 info.mCrop = ds.crop_legacy;
chaviw13fdc492017-06-27 12:40:18 -07001499 info.mColor = ds.color;
Kalle Raitaa099a242017-01-11 11:17:29 -08001500 info.mFlags = ds.flags;
1501 info.mPixelFormat = getPixelFormat();
chaviw4244e032019-09-04 11:27:49 -07001502 info.mDataSpace = static_cast<android_dataspace>(getDataSpace());
Marissa Wallf58c14b2018-07-24 10:50:43 -07001503 info.mMatrix[0][0] = ds.active_legacy.transform[0][0];
1504 info.mMatrix[0][1] = ds.active_legacy.transform[0][1];
1505 info.mMatrix[1][0] = ds.active_legacy.transform[1][0];
1506 info.mMatrix[1][1] = ds.active_legacy.transform[1][1];
Kalle Raitaa099a242017-01-11 11:17:29 -08001507 {
chaviwd62d3062019-09-04 14:48:02 -07001508 sp<const GraphicBuffer> buffer = getBuffer();
David Sodman5b4cffc2017-11-23 13:20:29 -08001509 if (buffer != 0) {
1510 info.mActiveBufferWidth = buffer->getWidth();
1511 info.mActiveBufferHeight = buffer->getHeight();
1512 info.mActiveBufferStride = buffer->getStride();
1513 info.mActiveBufferFormat = buffer->format;
Kalle Raitaa099a242017-01-11 11:17:29 -08001514 } else {
1515 info.mActiveBufferWidth = 0;
1516 info.mActiveBufferHeight = 0;
1517 info.mActiveBufferStride = 0;
1518 info.mActiveBufferFormat = 0;
1519 }
Mathias Agopian13127d82013-03-05 17:47:11 -08001520 }
Kalle Raitaa099a242017-01-11 11:17:29 -08001521 info.mNumQueuedFrames = getQueuedFrameCount();
1522 info.mRefreshPending = isBufferLatched();
1523 info.mIsOpaque = isOpaque(ds);
1524 info.mContentDirty = contentDirty;
1525 return info;
Mathias Agopian13127d82013-03-05 17:47:11 -08001526}
Chia-I Wu83ce7c12017-10-19 15:18:55 -07001527
Yiwei Zhang5434a782018-12-05 18:06:32 -08001528void Layer::miniDumpHeader(std::string& result) {
Yichi Chen6ca35192018-05-29 12:20:43 +08001529 result.append("-------------------------------");
1530 result.append("-------------------------------");
1531 result.append("-----------------------------\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001532 result.append(" Layer name\n");
1533 result.append(" Z | ");
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001534 result.append(" Window Type | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001535 result.append(" Comp Type | ");
Yichi Chen6ca35192018-05-29 12:20:43 +08001536 result.append(" Transform | ");
Dan Stozae22aec72016-08-01 13:20:59 -07001537 result.append(" Disp Frame (LTRB) | ");
1538 result.append(" Source Crop (LTRB)\n");
Yichi Chen6ca35192018-05-29 12:20:43 +08001539 result.append("-------------------------------");
1540 result.append("-------------------------------");
1541 result.append("-----------------------------\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001542}
1543
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001544void Layer::miniDump(std::string& result, const sp<DisplayDevice>& displayDevice) const {
1545 auto outputLayer = findOutputLayerForDisplay(displayDevice);
1546 if (!outputLayer) {
Dan Stozae22aec72016-08-01 13:20:59 -07001547 return;
1548 }
1549
Yiwei Zhang5434a782018-12-05 18:06:32 -08001550 std::string name;
Dan Stozae22aec72016-08-01 13:20:59 -07001551 if (mName.length() > 77) {
1552 std::string shortened;
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001553 shortened.append(mName, 0, 36);
Dan Stozae22aec72016-08-01 13:20:59 -07001554 shortened.append("[...]");
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001555 shortened.append(mName, mName.length() - 36);
1556 name = std::move(shortened);
Dan Stozae22aec72016-08-01 13:20:59 -07001557 } else {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001558 name = mName;
Dan Stozae22aec72016-08-01 13:20:59 -07001559 }
1560
Yiwei Zhang5434a782018-12-05 18:06:32 -08001561 StringAppendF(&result, " %s\n", name.c_str());
Dan Stozae22aec72016-08-01 13:20:59 -07001562
Alec Mourib416efd2018-09-06 21:01:59 +00001563 const State& layerState(getDrawingState());
Lloyd Piquede196652020-01-22 17:29:58 -08001564 const auto& outputLayerState = outputLayer->getState();
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001565
Chia-I Wu1e043612018-03-01 09:45:09 -08001566 if (layerState.zOrderRelativeOf != nullptr || mDrawingParent != nullptr) {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001567 StringAppendF(&result, " rel %6d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001568 } else {
Yiwei Zhang5434a782018-12-05 18:06:32 -08001569 StringAppendF(&result, " %10d | ", layerState.z);
Chia-I Wu1e043612018-03-01 09:45:09 -08001570 }
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001571 StringAppendF(&result, " %10d | ", mWindowType);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001572 StringAppendF(&result, "%10s | ", toString(getCompositionType(displayDevice)).c_str());
Lloyd Piquede196652020-01-22 17:29:58 -08001573 StringAppendF(&result, "%10s | ", toString(outputLayerState.bufferTransform).c_str());
1574 const Rect& frame = outputLayerState.displayFrame;
Yiwei Zhang5434a782018-12-05 18:06:32 -08001575 StringAppendF(&result, "%4d %4d %4d %4d | ", frame.left, frame.top, frame.right, frame.bottom);
Lloyd Piquede196652020-01-22 17:29:58 -08001576 const FloatRect& crop = outputLayerState.sourceCrop;
Yiwei Zhang5434a782018-12-05 18:06:32 -08001577 StringAppendF(&result, "%6.1f %6.1f %6.1f %6.1f\n", crop.left, crop.top, crop.right,
1578 crop.bottom);
Dan Stozae22aec72016-08-01 13:20:59 -07001579
Yichi Chen6ca35192018-05-29 12:20:43 +08001580 result.append("- - - - - - - - - - - - - - - -");
1581 result.append("- - - - - - - - - - - - - - - -");
1582 result.append("- - - - - - - - - - - - - - -\n");
Dan Stozae22aec72016-08-01 13:20:59 -07001583}
Dan Stozae22aec72016-08-01 13:20:59 -07001584
Yiwei Zhang5434a782018-12-05 18:06:32 -08001585void Layer::dumpFrameStats(std::string& result) const {
Svetoslavd85084b2014-03-20 10:28:31 -07001586 mFrameTracker.dumpStats(result);
Mathias Agopian13127d82013-03-05 17:47:11 -08001587}
1588
Svetoslavd85084b2014-03-20 10:28:31 -07001589void Layer::clearFrameStats() {
1590 mFrameTracker.clearStats();
Mathias Agopian13127d82013-03-05 17:47:11 -08001591}
1592
Jamie Gennis6547ff42013-07-16 20:12:42 -07001593void Layer::logFrameStats() {
1594 mFrameTracker.logAndResetStats(mName);
1595}
1596
Svetoslavd85084b2014-03-20 10:28:31 -07001597void Layer::getFrameStats(FrameStats* outStats) const {
1598 mFrameTracker.getStats(outStats);
1599}
1600
Yiwei Zhang5434a782018-12-05 18:06:32 -08001601void Layer::dumpFrameEvents(std::string& result) {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001602 StringAppendF(&result, "- Layer %s (%s, %p)\n", getName().c_str(), getType(), this);
Brian Andersond6927fb2016-07-23 23:37:30 -07001603 Mutex::Autolock lock(mFrameEventHistoryMutex);
1604 mFrameEventHistory.checkFencesForCompletion();
1605 mFrameEventHistory.dump(result);
1606}
Pablo Ceballos40845df2016-01-25 17:41:15 -08001607
Vishnu Nair0f085c62019-08-30 08:49:12 -07001608void Layer::dumpCallingUidPid(std::string& result) const {
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001609 StringAppendF(&result, "Layer %s (%s) pid:%d uid:%d\n", getName().c_str(), getType(),
Vishnu Nair0f085c62019-08-30 08:49:12 -07001610 mCallingPid, mCallingUid);
1611}
1612
Brian Anderson5ea5e592016-12-01 16:54:33 -08001613void Layer::onDisconnect() {
1614 Mutex::Autolock lock(mFrameEventHistoryMutex);
1615 mFrameEventHistory.onDisconnect();
Yiwei Zhang1a88c402019-11-18 10:43:58 -08001616 const int32_t layerId = getSequence();
1617 mFlinger->mTimeStats->onDestroy(layerId);
1618 mFlinger->mFrameTracer->onDestroy(layerId);
Brian Anderson5ea5e592016-12-01 16:54:33 -08001619}
1620
Brian Anderson3890c392016-07-25 12:48:08 -07001621void Layer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps,
David Sodman41fdfc92017-11-06 16:09:56 -08001622 FrameEventHistoryDelta* outDelta) {
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001623 if (newTimestamps) {
Yiwei Zhang7e666a52018-11-15 13:33:42 -08001624 mFlinger->mTimeStats->setPostTime(getSequence(), newTimestamps->frameNumber,
1625 getName().c_str(), newTimestamps->postedTime);
Yiwei Zhang487340f2019-11-18 17:42:12 -08001626 mFlinger->mTimeStats->setAcquireFence(getSequence(), newTimestamps->frameNumber,
1627 newTimestamps->acquireFence);
Yiwei Zhangfaf3ded2018-05-02 17:37:17 -07001628 }
1629
Brian Andersond6927fb2016-07-23 23:37:30 -07001630 Mutex::Autolock lock(mFrameEventHistoryMutex);
1631 if (newTimestamps) {
Brian Andersonfbc80ae2017-05-26 16:23:54 -07001632 // If there are any unsignaled fences in the aquire timeline at this
1633 // point, the previously queued frame hasn't been latched yet. Go ahead
1634 // and try to get the signal time here so the syscall is taken out of
1635 // the main thread's critical path.
1636 mAcquireTimeline.updateSignalTimes();
1637 // Push the new fence after updating since it's likely still pending.
Brian Anderson3d4039d2016-09-23 16:31:30 -07001638 mAcquireTimeline.push(newTimestamps->acquireFence);
Brian Andersond6927fb2016-07-23 23:37:30 -07001639 mFrameEventHistory.addQueue(*newTimestamps);
1640 }
1641
Brian Anderson3890c392016-07-25 12:48:08 -07001642 if (outDelta) {
1643 mFrameEventHistory.getAndResetDelta(outDelta);
Brian Andersond6927fb2016-07-23 23:37:30 -07001644 }
Pablo Ceballos40845df2016-01-25 17:41:15 -08001645}
Dan Stozae77c7662016-05-13 11:37:28 -07001646
Chia-I Wu98f1c102017-05-30 14:54:08 -07001647size_t Layer::getChildrenCount() const {
1648 size_t count = 0;
1649 for (const sp<Layer>& child : mCurrentChildren) {
1650 count += 1 + child->getChildrenCount();
1651 }
1652 return count;
1653}
1654
Robert Carr1f0a16a2016-10-24 16:27:39 -07001655void Layer::addChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001656 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001657 setTransactionFlags(eTransactionNeeded);
Robert Carr1323c952019-01-28 18:13:27 -08001658
Robert Carr1f0a16a2016-10-24 16:27:39 -07001659 mCurrentChildren.add(layer);
1660 layer->setParent(this);
Ady Abraham60e42ea2020-03-09 19:17:31 -07001661 updateTreeHasFrameRateVote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001662}
1663
1664ssize_t Layer::removeChild(const sp<Layer>& layer) {
Robert Carr1323c952019-01-28 18:13:27 -08001665 mChildrenChanged = true;
Robert Carr7f2ed8b2019-02-07 14:45:11 -08001666 setTransactionFlags(eTransactionNeeded);
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001667
Robert Carr1323c952019-01-28 18:13:27 -08001668 layer->setParent(nullptr);
Ady Abraham60e42ea2020-03-09 19:17:31 -07001669 const auto removeResult = mCurrentChildren.remove(layer);
1670
1671 updateTreeHasFrameRateVote();
1672 layer->updateTreeHasFrameRateVote();
1673
1674 return removeResult;
1675}
1676
1677void Layer::reparentChildren(const sp<Layer>& newParent) {
1678 if (attachChildren()) {
1679 setTransactionFlags(eTransactionNeeded);
1680 }
1681
1682 for (const sp<Layer>& child : mCurrentChildren) {
1683 newParent->addChild(child);
1684 }
1685 mCurrentChildren.clear();
1686 updateTreeHasFrameRateVote();
Robert Carr1f0a16a2016-10-24 16:27:39 -07001687}
1688
Robert Carr1db73f62016-12-21 12:58:51 -08001689bool Layer::reparentChildren(const sp<IBinder>& newParentHandle) {
1690 sp<Handle> handle = nullptr;
1691 sp<Layer> newParent = nullptr;
1692 if (newParentHandle == nullptr) {
1693 return false;
1694 }
1695 handle = static_cast<Handle*>(newParentHandle.get());
1696 newParent = handle->owner.promote();
1697 if (newParent == nullptr) {
1698 ALOGE("Unable to promote Layer handle");
1699 return false;
1700 }
1701
Ady Abraham60e42ea2020-03-09 19:17:31 -07001702 reparentChildren(newParent);
Robert Carr1db73f62016-12-21 12:58:51 -08001703
1704 return true;
1705}
1706
Robert Carr15eae092018-03-23 13:43:53 -07001707void Layer::setChildrenDrawingParent(const sp<Layer>& newParent) {
Robert Carr578038f2018-03-09 12:25:24 -08001708 for (const sp<Layer>& child : mDrawingChildren) {
1709 child->mDrawingParent = newParent;
Vishnu Nairc652ff82019-03-15 12:48:54 -07001710 child->computeBounds(newParent->mBounds,
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001711 newParent->getTransformWithScale(newParent->getBufferScaleTransform()),
1712 newParent->mEffectiveShadowRadius);
Robert Carr578038f2018-03-09 12:25:24 -08001713 }
1714}
1715
chaviwf1961f72017-09-18 16:41:07 -07001716bool Layer::reparent(const sp<IBinder>& newParentHandle) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001717 bool callSetTransactionFlags = false;
chaviw06178942017-07-27 10:25:59 -07001718
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001719 // While layers are detached, we allow most operations
1720 // and simply halt performing the actual transaction. However
1721 // for reparent != null we would enter the mRemovedFromCurrentState
1722 // state, regardless of whether doTransaction was called, and
1723 // so we need to prevent the update here.
1724 if (mLayerDetached && newParentHandle == nullptr) {
chaviw06178942017-07-27 10:25:59 -07001725 return false;
1726 }
1727
Robert Carr54cf5b12019-01-25 14:02:28 -08001728 sp<Layer> newParent;
1729 if (newParentHandle != nullptr) {
1730 auto handle = static_cast<Handle*>(newParentHandle.get());
1731 newParent = handle->owner.promote();
1732 if (newParent == nullptr) {
1733 ALOGE("Unable to promote Layer handle");
1734 return false;
1735 }
1736 if (newParent == this) {
1737 ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str());
1738 return false;
1739 }
1740 }
1741
chaviwf1961f72017-09-18 16:41:07 -07001742 sp<Layer> parent = getParent();
1743 if (parent != nullptr) {
1744 parent->removeChild(this);
chaviw06178942017-07-27 10:25:59 -07001745 }
1746
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001747 if (newParentHandle != nullptr) {
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001748 newParent->addChild(this);
1749 if (!newParent->isRemovedFromCurrentState()) {
1750 addToCurrentState();
1751 } else {
1752 onRemovedFromCurrentState();
1753 }
1754
1755 if (mLayerDetached) {
1756 mLayerDetached = false;
1757 callSetTransactionFlags = true;
1758 }
1759 } else {
1760 onRemovedFromCurrentState();
chaviw61626f22018-11-15 16:26:27 -08001761 }
1762
Robert Carr6fb1a7e2018-12-11 12:07:25 -08001763 if (callSetTransactionFlags || attachChildren()) {
chaviw5aedec92018-10-22 10:40:38 -07001764 setTransactionFlags(eTransactionNeeded);
1765 }
chaviw06178942017-07-27 10:25:59 -07001766 return true;
1767}
1768
Robert Carr9524cb32017-02-13 11:32:32 -08001769bool Layer::detachChildren() {
Robert Carr7f619b22017-11-06 12:56:35 -08001770 for (const sp<Layer>& child : mCurrentChildren) {
chaviw161410b02017-07-27 10:46:08 -07001771 sp<Client> parentClient = mClientRef.promote();
Robert Carr9524cb32017-02-13 11:32:32 -08001772 sp<Client> client(child->mClientRef.promote());
chaviw161410b02017-07-27 10:46:08 -07001773 if (client != nullptr && parentClient != client) {
chaviw5aedec92018-10-22 10:40:38 -07001774 child->mLayerDetached = true;
Robert Carr7f619b22017-11-06 12:56:35 -08001775 child->detachChildren();
chaviw43cb3cb2019-05-31 15:23:41 -07001776 child->removeRemoteSyncPoints();
Robert Carr9524cb32017-02-13 11:32:32 -08001777 }
Robert Carr7f619b22017-11-06 12:56:35 -08001778 }
Robert Carr9524cb32017-02-13 11:32:32 -08001779
1780 return true;
1781}
1782
chaviw5aedec92018-10-22 10:40:38 -07001783bool Layer::attachChildren() {
1784 bool changed = false;
1785 for (const sp<Layer>& child : mCurrentChildren) {
1786 sp<Client> parentClient = mClientRef.promote();
1787 sp<Client> client(child->mClientRef.promote());
1788 if (client != nullptr && parentClient != client) {
1789 if (child->mLayerDetached) {
1790 child->mLayerDetached = false;
1791 changed = true;
1792 }
1793 changed |= child->attachChildren();
1794 }
1795 }
1796
1797 return changed;
1798}
1799
Peiyong Lind3788632018-09-18 16:01:31 -07001800bool Layer::setColorTransform(const mat4& matrix) {
Peiyong Lin747321c2018-10-01 10:03:11 -07001801 static const mat4 identityMatrix = mat4();
1802
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001803 if (mCurrentState.colorTransform == matrix) {
Peiyong Lind3788632018-09-18 16:01:31 -07001804 return false;
1805 }
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001806 ++mCurrentState.sequence;
1807 mCurrentState.colorTransform = matrix;
1808 mCurrentState.hasColorTransform = matrix != identityMatrix;
1809 mCurrentState.modified = true;
Peiyong Lind3788632018-09-18 16:01:31 -07001810 setTransactionFlags(eTransactionNeeded);
1811 return true;
1812}
1813
chaviwf66724d2018-11-28 16:35:21 -08001814mat4 Layer::getColorTransform() const {
1815 mat4 colorTransform = mat4(getDrawingState().colorTransform);
1816 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
1817 colorTransform = parent->getColorTransform() * colorTransform;
1818 }
1819 return colorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07001820}
1821
1822bool Layer::hasColorTransform() const {
chaviwf66724d2018-11-28 16:35:21 -08001823 bool hasColorTransform = getDrawingState().hasColorTransform;
1824 if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
1825 hasColorTransform = hasColorTransform || parent->hasColorTransform();
1826 }
1827 return hasColorTransform;
Peiyong Lind3788632018-09-18 16:01:31 -07001828}
1829
Chia-I Wu11481472018-05-04 10:43:19 -07001830bool Layer::isLegacyDataSpace() const {
1831 // return true when no higher bits are set
chaviw4244e032019-09-04 11:27:49 -07001832 return !(getDataSpace() &
1833 (ui::Dataspace::STANDARD_MASK | ui::Dataspace::TRANSFER_MASK |
1834 ui::Dataspace::RANGE_MASK));
Peiyong Lindd9b2ae2018-03-01 16:22:45 -08001835}
1836
Robert Carr1f0a16a2016-10-24 16:27:39 -07001837void Layer::setParent(const sp<Layer>& layer) {
Chia-I Wue41dbe62017-06-13 14:10:56 -07001838 mCurrentParent = layer;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001839}
1840
chaviw301b1d82019-11-06 13:15:09 -08001841int32_t Layer::getZ(LayerVector::StateSet stateSet) const {
1842 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1843 const State& state = useDrawing ? mDrawingState : mCurrentState;
1844 return state.z;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001845}
1846
Robert Carr1c5481e2019-07-01 14:42:27 -07001847bool Layer::usingRelativeZ(LayerVector::StateSet stateSet) const {
Robert Carr29abff82017-12-04 13:51:20 -08001848 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001849 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviwe5ac40f2019-09-24 16:36:55 -07001850 return state.isRelativeOf;
Robert Carr29abff82017-12-04 13:51:20 -08001851}
1852
David Sodman41fdfc92017-11-06 16:09:56 -08001853__attribute__((no_sanitize("unsigned-integer-overflow"))) LayerVector Layer::makeTraversalList(
Robert Carr29abff82017-12-04 13:51:20 -08001854 LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers) {
Dan Stoza412903f2017-04-27 13:42:17 -07001855 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
1856 "makeTraversalList received invalid stateSet");
1857 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1858 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001859 const State& state = useDrawing ? mDrawingState : mCurrentState;
Dan Stoza412903f2017-04-27 13:42:17 -07001860
Robert Carr29abff82017-12-04 13:51:20 -08001861 if (state.zOrderRelatives.size() == 0) {
1862 *outSkipRelativeZUsers = true;
1863 return children;
1864 }
1865
chaviwfd462612018-05-31 16:11:27 -07001866 LayerVector traverse(stateSet);
Dan Stoza412903f2017-04-27 13:42:17 -07001867 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
Robert Carrdb66e622017-04-10 16:55:57 -07001868 sp<Layer> strongRelative = weakRelative.promote();
1869 if (strongRelative != nullptr) {
1870 traverse.add(strongRelative);
Robert Carrdb66e622017-04-10 16:55:57 -07001871 }
1872 }
1873
Dan Stoza412903f2017-04-27 13:42:17 -07001874 for (const sp<Layer>& child : children) {
chaviwe5ac40f2019-09-24 16:36:55 -07001875 if (child->usingRelativeZ(stateSet)) {
Robert Carr503c7042017-09-27 15:06:08 -07001876 continue;
1877 }
Robert Carrdb66e622017-04-10 16:55:57 -07001878 traverse.add(child);
1879 }
1880
1881 return traverse;
1882}
1883
Robert Carr1f0a16a2016-10-24 16:27:39 -07001884/**
Robert Carrdb66e622017-04-10 16:55:57 -07001885 * Negatively signed relatives are before 'this' in Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07001886 */
Dan Stoza412903f2017-04-27 13:42:17 -07001887void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08001888 // In the case we have other layers who are using a relative Z to us, makeTraversalList will
1889 // produce a new list for traversing, including our relatives, and not including our children
1890 // who are relatives of another surface. In the case that there are no relative Z,
1891 // makeTraversalList returns our children directly to avoid significant overhead.
1892 // However in this case we need to take the responsibility for filtering children which
1893 // are relatives of another surface here.
1894 bool skipRelativeZUsers = false;
1895 const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07001896
Robert Carr1f0a16a2016-10-24 16:27:39 -07001897 size_t i = 0;
Robert Carrdb66e622017-04-10 16:55:57 -07001898 for (; i < list.size(); i++) {
1899 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001900 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1901 continue;
1902 }
1903
chaviw301b1d82019-11-06 13:15:09 -08001904 if (relative->getZ(stateSet) >= 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001905 break;
Robert Carrdb66e622017-04-10 16:55:57 -07001906 }
Dan Stoza412903f2017-04-27 13:42:17 -07001907 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001908 }
Robert Carr29abff82017-12-04 13:51:20 -08001909
Dan Stoza412903f2017-04-27 13:42:17 -07001910 visitor(this);
Robert Carrdb66e622017-04-10 16:55:57 -07001911 for (; i < list.size(); i++) {
1912 const auto& relative = list[i];
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001913
Robert Carr29abff82017-12-04 13:51:20 -08001914 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1915 continue;
1916 }
Dan Stoza412903f2017-04-27 13:42:17 -07001917 relative->traverseInZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001918 }
1919}
1920
1921/**
Robert Carrdb66e622017-04-10 16:55:57 -07001922 * Positively signed relatives are before 'this' in reverse Z-order.
Robert Carr1f0a16a2016-10-24 16:27:39 -07001923 */
Dan Stoza412903f2017-04-27 13:42:17 -07001924void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet,
1925 const LayerVector::Visitor& visitor) {
Robert Carr29abff82017-12-04 13:51:20 -08001926 // See traverseInZOrder for documentation.
1927 bool skipRelativeZUsers = false;
1928 LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -07001929
Robert Carr1f0a16a2016-10-24 16:27:39 -07001930 int32_t i = 0;
Joel Galensonbf324992017-11-06 11:04:12 -08001931 for (i = int32_t(list.size()) - 1; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07001932 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001933
1934 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1935 continue;
1936 }
1937
chaviw301b1d82019-11-06 13:15:09 -08001938 if (relative->getZ(stateSet) < 0) {
Robert Carr1f0a16a2016-10-24 16:27:39 -07001939 break;
1940 }
Dan Stoza412903f2017-04-27 13:42:17 -07001941 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001942 }
Dan Stoza412903f2017-04-27 13:42:17 -07001943 visitor(this);
David Sodman41fdfc92017-11-06 16:09:56 -08001944 for (; i >= 0; i--) {
Robert Carrdb66e622017-04-10 16:55:57 -07001945 const auto& relative = list[i];
Robert Carr29abff82017-12-04 13:51:20 -08001946
1947 if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
1948 continue;
1949 }
1950
Dan Stoza412903f2017-04-27 13:42:17 -07001951 relative->traverseInReverseZOrder(stateSet, visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001952 }
1953}
1954
Edgar Arriaga844fa672020-01-16 14:21:42 -08001955void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) {
1956 visitor(this);
1957 const LayerVector& children =
1958 state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren;
1959 for (const sp<Layer>& child : children) {
1960 child->traverse(state, visitor);
1961 }
1962}
1963
chaviw4b129c22018-04-09 16:19:43 -07001964LayerVector Layer::makeChildrenTraversalList(LayerVector::StateSet stateSet,
1965 const std::vector<Layer*>& layersInTree) {
1966 LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
1967 "makeTraversalList received invalid stateSet");
chaviwa76b2712017-09-20 12:02:26 -07001968 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
1969 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001970 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07001971
chaviwfd462612018-05-31 16:11:27 -07001972 LayerVector traverse(stateSet);
chaviw4b129c22018-04-09 16:19:43 -07001973 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
1974 sp<Layer> strongRelative = weakRelative.promote();
1975 // Only add relative layers that are also descendents of the top most parent of the tree.
1976 // If a relative layer is not a descendent, then it should be ignored.
1977 if (std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
1978 traverse.add(strongRelative);
1979 }
1980 }
1981
1982 for (const sp<Layer>& child : children) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001983 const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState;
chaviw4b129c22018-04-09 16:19:43 -07001984 // If a layer has a relativeOf layer, only ignore if the layer it's relative to is a
1985 // descendent of the top most parent of the tree. If it's not a descendent, then just add
1986 // the child here since it won't be added later as a relative.
1987 if (std::binary_search(layersInTree.begin(), layersInTree.end(),
1988 childState.zOrderRelativeOf.promote().get())) {
1989 continue;
1990 }
1991 traverse.add(child);
1992 }
1993
1994 return traverse;
1995}
1996
1997void Layer::traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
1998 LayerVector::StateSet stateSet,
1999 const LayerVector::Visitor& visitor) {
2000 const LayerVector list = makeChildrenTraversalList(stateSet, layersInTree);
chaviwa76b2712017-09-20 12:02:26 -07002001
2002 size_t i = 0;
chaviw4b129c22018-04-09 16:19:43 -07002003 for (; i < list.size(); i++) {
2004 const auto& relative = list[i];
chaviw301b1d82019-11-06 13:15:09 -08002005 if (relative->getZ(stateSet) >= 0) {
chaviwa76b2712017-09-20 12:02:26 -07002006 break;
2007 }
chaviw4b129c22018-04-09 16:19:43 -07002008 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07002009 }
chaviw4b129c22018-04-09 16:19:43 -07002010
chaviwa76b2712017-09-20 12:02:26 -07002011 visitor(this);
chaviw4b129c22018-04-09 16:19:43 -07002012 for (; i < list.size(); i++) {
2013 const auto& relative = list[i];
2014 relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
chaviwa76b2712017-09-20 12:02:26 -07002015 }
2016}
2017
chaviw4b129c22018-04-09 16:19:43 -07002018std::vector<Layer*> Layer::getLayersInTree(LayerVector::StateSet stateSet) {
2019 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2020 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
2021
2022 std::vector<Layer*> layersInTree = {this};
2023 for (size_t i = 0; i < children.size(); i++) {
2024 const auto& child = children[i];
2025 std::vector<Layer*> childLayers = child->getLayersInTree(stateSet);
2026 layersInTree.insert(layersInTree.end(), childLayers.cbegin(), childLayers.cend());
2027 }
2028
2029 return layersInTree;
2030}
2031
2032void Layer::traverseChildrenInZOrder(LayerVector::StateSet stateSet,
2033 const LayerVector::Visitor& visitor) {
2034 std::vector<Layer*> layersInTree = getLayersInTree(stateSet);
2035 std::sort(layersInTree.begin(), layersInTree.end());
2036 traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
2037}
2038
Peiyong Linefefaac2018-08-17 12:27:51 -07002039ui::Transform Layer::getTransform() const {
Vishnu Nairf0c28512019-02-08 12:40:28 -08002040 return mEffectiveTransform;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002041}
2042
chaviw13fdc492017-06-27 12:40:18 -07002043half Layer::getAlpha() const {
Ady Abraham83729882018-12-07 12:26:48 -08002044 const auto& p = mDrawingParent.promote();
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002045
chaviw13fdc492017-06-27 12:40:18 -07002046 half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf;
2047 return parentAlpha * getDrawingState().color.a;
Robert Carr6452f122017-03-21 10:41:29 -07002048}
Robert Carr6452f122017-03-21 10:41:29 -07002049
chaviw13fdc492017-06-27 12:40:18 -07002050half4 Layer::getColor() const {
2051 const half4 color(getDrawingState().color);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002052 return half4(color.r, color.g, color.b, getAlpha());
Robert Carr6452f122017-03-21 10:41:29 -07002053}
Robert Carr6452f122017-03-21 10:41:29 -07002054
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08002055int32_t Layer::getBackgroundBlurRadius() const {
2056 return getDrawingState().backgroundBlurRadius;
2057}
2058
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002059Layer::RoundedCornerState Layer::getRoundedCornerState() const {
2060 const auto& p = mDrawingParent.promote();
2061 if (p != nullptr) {
Peiyong Lin27016a92019-03-29 17:36:08 +00002062 RoundedCornerState parentState = p->getRoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002063 if (parentState.radius > 0) {
2064 ui::Transform t = getActiveTransform(getDrawingState());
2065 t = t.inverse();
2066 parentState.cropRect = t.transform(parentState.cropRect);
2067 // The rounded corners shader only accepts 1 corner radius for performance reasons,
2068 // but a transform matrix can define horizontal and vertical scales.
2069 // Let's take the average between both of them and pass into the shader, practically we
2070 // never do this type of transformation on windows anyway.
2071 parentState.radius *= (t[0][0] + t[1][1]) / 2.0f;
2072 return parentState;
2073 }
2074 }
2075 const float radius = getDrawingState().cornerRadius;
Peiyong Linb9ff23e2019-04-08 11:04:59 -07002076 return radius > 0 && getCrop(getDrawingState()).isValid()
2077 ? RoundedCornerState(getCrop(getDrawingState()).toFloatRect(), radius)
2078 : RoundedCornerState();
Lucas Dupin1b6531c2018-07-05 17:18:21 -07002079}
2080
Vishnu Nair08f6eae2019-11-26 14:01:39 -08002081renderengine::ShadowSettings Layer::getShadowSettings(const Rect& viewport) const {
2082 renderengine::ShadowSettings state = mFlinger->mDrawingState.globalShadowSettings;
2083
2084 // Shift the spot light x-position to the middle of the display and then
2085 // offset it by casting layer's screen pos.
2086 state.lightPos.x = (viewport.width() / 2.f) - mScreenBounds.left;
2087 state.lightPos.y -= mScreenBounds.top;
2088
2089 state.length = mEffectiveShadowRadius;
2090 return state;
2091}
2092
Robert Carr1f0a16a2016-10-24 16:27:39 -07002093void Layer::commitChildList() {
2094 for (size_t i = 0; i < mCurrentChildren.size(); i++) {
2095 const auto& child = mCurrentChildren[i];
2096 child->commitChildList();
2097 }
2098 mDrawingChildren = mCurrentChildren;
Chia-I Wue41dbe62017-06-13 14:10:56 -07002099 mDrawingParent = mCurrentParent;
Robert Carr1f0a16a2016-10-24 16:27:39 -07002100}
2101
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002102static wp<Layer> extractLayerFromBinder(const wp<IBinder>& weakBinderHandle) {
2103 if (weakBinderHandle == nullptr) {
2104 return nullptr;
2105 }
2106 sp<IBinder> binderHandle = weakBinderHandle.promote();
2107 if (binderHandle == nullptr) {
2108 return nullptr;
2109 }
2110 sp<Layer::Handle> handle = static_cast<Layer::Handle*>(binderHandle.get());
2111 if (handle == nullptr) {
2112 return nullptr;
2113 }
2114 return handle->owner;
2115}
2116
Robert Carr720e5062018-07-30 17:45:14 -07002117void Layer::setInputInfo(const InputWindowInfo& info) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002118 mCurrentState.inputInfo = info;
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002119 mCurrentState.touchableRegionCrop = extractLayerFromBinder(info.touchableRegionCropHandle);
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002120 mCurrentState.modified = true;
2121 mCurrentState.inputInfoChanged = true;
Robert Carr720e5062018-07-30 17:45:14 -07002122 setTransactionFlags(eTransactionNeeded);
2123}
2124
Alec Mouri6b9e9912020-01-21 10:50:24 -08002125LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags,
2126 const sp<const DisplayDevice>& device) const {
chaviw08f3cb22020-01-13 13:17:21 -08002127 LayerProto* layerProto = layersProto.add_layers();
2128 writeToProtoDrawingState(layerProto, traceFlags);
2129 writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);
2130
Alec Mouri6b9e9912020-01-21 10:50:24 -08002131 // Only populate for the primary display.
2132 if (device) {
2133 const Hwc2::IComposerClient::Composition compositionType = getCompositionType(device);
2134 layerProto->set_hwc_composition_type(static_cast<HwcCompositionType>(compositionType));
2135 }
2136
chaviw08f3cb22020-01-13 13:17:21 -08002137 for (const sp<Layer>& layer : mDrawingChildren) {
Alec Mouri6b9e9912020-01-21 10:50:24 -08002138 layer->writeToProto(layersProto, traceFlags, device);
chaviw08f3cb22020-01-13 13:17:21 -08002139 }
chaviw6d89e2d2020-01-14 14:42:01 -08002140
2141 return layerProto;
chaviw08f3cb22020-01-13 13:17:21 -08002142}
2143
Vishnu Nair8406fd72019-07-30 11:29:31 -07002144void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags) const {
2145 ui::Transform transform = getTransform();
2146
2147 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
2148 for (const auto& pendingState : mPendingStatesSnapshot) {
2149 auto barrierLayer = pendingState.barrierLayer_legacy.promote();
2150 if (barrierLayer != nullptr) {
2151 BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();
2152 barrierLayerProto->set_id(barrierLayer->sequence);
2153 barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);
2154 }
2155 }
2156
chaviwd62d3062019-09-04 14:48:02 -07002157 auto buffer = getBuffer();
Vishnu Nair8406fd72019-07-30 11:29:31 -07002158 if (buffer != nullptr) {
2159 LayerProtoHelper::writeToProto(buffer,
2160 [&]() { return layerInfo->mutable_active_buffer(); });
chaviw4244e032019-09-04 11:27:49 -07002161 LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()),
Vishnu Nair8406fd72019-07-30 11:29:31 -07002162 layerInfo->mutable_buffer_transform());
2163 }
2164 layerInfo->set_invalidate(contentDirty);
2165 layerInfo->set_is_protected(isProtected());
chaviw4244e032019-09-04 11:27:49 -07002166 layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(getDataSpace())));
Vishnu Nair8406fd72019-07-30 11:29:31 -07002167 layerInfo->set_queued_frames(getQueuedFrameCount());
2168 layerInfo->set_refresh_pending(isBufferLatched());
2169 layerInfo->set_curr_frame(mCurrentFrameNumber);
2170 layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());
2171
2172 layerInfo->set_corner_radius(getRoundedCornerState().radius);
2173 LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());
2174 LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),
2175 [&]() { return layerInfo->mutable_position(); });
2176 LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
Lloyd Piquea2468662019-03-07 21:31:06 -08002177 LayerProtoHelper::writeToProto(debugGetVisibleRegionOnDefaultDisplay(),
Vishnu Nair8406fd72019-07-30 11:29:31 -07002178 [&]() { return layerInfo->mutable_visible_region(); });
2179 LayerProtoHelper::writeToProto(surfaceDamageRegion,
2180 [&]() { return layerInfo->mutable_damage_region(); });
chaviwddeae262020-01-06 10:31:23 -08002181
2182 if (hasColorTransform()) {
2183 LayerProtoHelper::writeToProto(getColorTransform(),
2184 layerInfo->mutable_color_transform());
2185 }
Vishnu Nair8406fd72019-07-30 11:29:31 -07002186 }
2187
2188 if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
2189 LayerProtoHelper::writeToProto(mSourceBounds,
2190 [&]() { return layerInfo->mutable_source_bounds(); });
2191 LayerProtoHelper::writeToProto(mScreenBounds,
2192 [&]() { return layerInfo->mutable_screen_bounds(); });
Vishnu Nair95a1ed42019-12-06 12:25:11 -08002193 LayerProtoHelper::writeToProto(getRoundedCornerState().cropRect,
2194 [&]() { return layerInfo->mutable_corner_radius_crop(); });
2195 layerInfo->set_shadow_radius(mEffectiveShadowRadius);
Vishnu Nair8406fd72019-07-30 11:29:31 -07002196 }
2197}
2198
2199void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,
2200 uint32_t traceFlags) const {
chaviw1d044282017-09-27 12:19:28 -07002201 const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
2202 const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002203 const State& state = useDrawing ? mDrawingState : mCurrentState;
chaviw1d044282017-09-27 12:19:28 -07002204
Peiyong Linefefaac2018-08-17 12:27:51 -07002205 ui::Transform requestedTransform = state.active_legacy.transform;
chaviw1d044282017-09-27 12:19:28 -07002206
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002207 if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
2208 layerInfo->set_id(sequence);
2209 layerInfo->set_name(getName().c_str());
chaviw8a01fa42019-08-19 12:39:31 -07002210 layerInfo->set_type(getType());
chaviw1d044282017-09-27 12:19:28 -07002211
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002212 for (const auto& child : children) {
2213 layerInfo->add_children(child->sequence);
chaviw1d044282017-09-27 12:19:28 -07002214 }
chaviw1d044282017-09-27 12:19:28 -07002215
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002216 for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
2217 sp<Layer> strongRelative = weakRelative.promote();
2218 if (strongRelative != nullptr) {
2219 layerInfo->add_relatives(strongRelative->sequence);
2220 }
chaviwadc40c22018-07-10 16:57:27 -07002221 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002222
2223 LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,
2224 [&]() { return layerInfo->mutable_transparent_region(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002225
2226 layerInfo->set_layer_stack(getLayerStack());
2227 layerInfo->set_z(state.z);
2228
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002229 LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),
2230 [&]() {
2231 return layerInfo->mutable_requested_position();
2232 });
2233
2234 LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h,
2235 [&]() { return layerInfo->mutable_size(); });
2236
2237 LayerProtoHelper::writeToProto(state.crop_legacy,
2238 [&]() { return layerInfo->mutable_crop(); });
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002239
2240 layerInfo->set_is_opaque(isOpaque(state));
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002241
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002242
2243 layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));
2244 LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
2245 LayerProtoHelper::writeToProto(state.color,
2246 [&]() { return layerInfo->mutable_requested_color(); });
2247 layerInfo->set_flags(state.flags);
2248
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002249 LayerProtoHelper::writeToProto(requestedTransform,
2250 layerInfo->mutable_requested_transform());
2251
2252 auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();
2253 if (parent != nullptr) {
2254 layerInfo->set_parent(parent->sequence);
2255 } else {
2256 layerInfo->set_parent(-1);
2257 }
2258
2259 auto zOrderRelativeOf = state.zOrderRelativeOf.promote();
2260 if (zOrderRelativeOf != nullptr) {
2261 layerInfo->set_z_order_relative_of(zOrderRelativeOf->sequence);
2262 } else {
2263 layerInfo->set_z_order_relative_of(-1);
2264 }
chaviw08f3cb22020-01-13 13:17:21 -08002265
2266 layerInfo->set_is_relative_of(state.isRelativeOf);
chaviwadc40c22018-07-10 16:57:27 -07002267 }
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002268
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002269 if (traceFlags & SurfaceTracing::TRACE_INPUT) {
2270 LayerProtoHelper::writeToProto(state.inputInfo, state.touchableRegionCrop,
2271 [&]() { return layerInfo->mutable_input_window_info(); });
Evan Rosky1f6d6d52018-12-06 10:47:26 -08002272 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002273
2274 if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
2275 auto protoMap = layerInfo->mutable_metadata();
2276 for (const auto& entry : state.metadata.mMap) {
2277 (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());
2278 }
Vishnu Nair9245d3b2019-03-22 13:38:56 -07002279 }
chaviw1d044282017-09-27 12:19:28 -07002280}
2281
Robert Carr2e102c92018-10-23 12:11:15 -07002282bool Layer::isRemovedFromCurrentState() const {
2283 return mRemovedFromCurrentState;
2284}
2285
Arthur Hungd20b2702019-01-14 18:16:16 +08002286InputWindowInfo Layer::fillInputInfo() {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002287 InputWindowInfo info = mDrawingState.inputInfo;
chaviwaf87b3e2019-10-01 16:59:28 -07002288 info.id = sequence;
Robert Carr720e5062018-07-30 17:45:14 -07002289
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002290 if (info.displayId == ADISPLAY_ID_NONE) {
chaviwb15ea8a2019-09-03 12:40:22 -07002291 info.displayId = getLayerStack();
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002292 }
2293
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002294 ui::Transform t = getTransform();
2295 const float xScale = t.sx();
2296 const float yScale = t.sy();
Ady Abraham282f1d72019-07-24 18:05:56 -07002297 int32_t xSurfaceInset = info.surfaceInset;
2298 int32_t ySurfaceInset = info.surfaceInset;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002299 if (xScale != 1.0f || yScale != 1.0f) {
Ady Abraham282f1d72019-07-24 18:05:56 -07002300 info.windowXScale *= (xScale != 0.0f) ? 1.0f / xScale : 0.0f;
2301 info.windowYScale *= (yScale != 0.0f) ? 1.0f / yScale : 0.0f;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002302 info.touchableRegion.scaleSelf(xScale, yScale);
Ady Abraham282f1d72019-07-24 18:05:56 -07002303 xSurfaceInset = std::round(xSurfaceInset * xScale);
2304 ySurfaceInset = std::round(ySurfaceInset * yScale);
Riddle Hsu39d4aa52018-11-30 20:46:53 +08002305 }
Robert Carre07e1032018-11-26 12:55:53 -08002306
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002307 // Transform layer size to screen space and inset it by surface insets.
Tiger Huang85b8c5e2019-01-17 18:34:54 +08002308 // If this is a portal window, set the touchableRegion to the layerBounds.
2309 Rect layerBounds = info.portalToDisplayId == ADISPLAY_ID_NONE
2310 ? getBufferSize(getDrawingState())
2311 : info.touchableRegion.getBounds();
Arthur Hungd20b2702019-01-14 18:16:16 +08002312 if (!layerBounds.isValid()) {
2313 layerBounds = getCroppedBufferSize(getDrawingState());
2314 }
Vishnu Nair8033a492018-12-05 07:27:23 -08002315 layerBounds = t.transform(layerBounds);
Ady Abraham282f1d72019-07-24 18:05:56 -07002316
2317 // clamp inset to layer bounds
2318 xSurfaceInset = (xSurfaceInset >= 0) ? std::min(xSurfaceInset, layerBounds.getWidth() / 2) : 0;
2319 ySurfaceInset = (ySurfaceInset >= 0) ? std::min(ySurfaceInset, layerBounds.getHeight() / 2) : 0;
2320
Arthur Hung118b1142019-05-08 21:25:59 +08002321 layerBounds.inset(xSurfaceInset, ySurfaceInset, xSurfaceInset, ySurfaceInset);
Vishnu Nair8033a492018-12-05 07:27:23 -08002322
Arthur Hungd20b2702019-01-14 18:16:16 +08002323 // Input coordinate should match the layer bounds.
2324 info.frameLeft = layerBounds.left;
2325 info.frameTop = layerBounds.top;
2326 info.frameRight = layerBounds.right;
2327 info.frameBottom = layerBounds.bottom;
Vishnu Nair8033a492018-12-05 07:27:23 -08002328
2329 // Position the touchable region relative to frame screen location and restrict it to frame
2330 // bounds.
2331 info.touchableRegion = info.touchableRegion.translate(info.frameLeft, info.frameTop);
chaviw3e727cd2019-01-31 13:41:05 -08002332 info.visible = canReceiveInput();
Vishnu Nair6fabeec2019-03-12 13:42:49 -07002333
2334 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2335 if (info.replaceTouchableRegionWithCrop) {
2336 if (cropLayer == nullptr) {
2337 info.touchableRegion = Region(Rect{mScreenBounds});
2338 } else {
2339 info.touchableRegion = Region(Rect{cropLayer->mScreenBounds});
2340 }
2341 } else if (cropLayer != nullptr) {
2342 info.touchableRegion = info.touchableRegion.intersect(Rect{cropLayer->mScreenBounds});
2343 }
2344
chaviwaf87b3e2019-10-01 16:59:28 -07002345 // If the layer is a clone, we need to crop the input region to cloned root to prevent
2346 // touches from going outside the cloned area.
2347 if (isClone()) {
2348 sp<Layer> clonedRoot = getClonedRoot();
2349 if (clonedRoot != nullptr) {
2350 Rect rect(clonedRoot->mScreenBounds);
2351 info.touchableRegion = info.touchableRegion.intersect(rect);
2352 }
2353 }
2354
Robert Carr720e5062018-07-30 17:45:14 -07002355 return info;
2356}
2357
chaviwaf87b3e2019-10-01 16:59:28 -07002358sp<Layer> Layer::getClonedRoot() {
2359 if (mClonedChild != nullptr) {
2360 return this;
2361 }
2362 if (mDrawingParent == nullptr || mDrawingParent.promote() == nullptr) {
2363 return nullptr;
2364 }
2365 return mDrawingParent.promote()->getClonedRoot();
2366}
2367
Robert Carr720e5062018-07-30 17:45:14 -07002368bool Layer::hasInput() const {
Lloyd Pique0449b0f2018-12-20 16:23:45 -08002369 return mDrawingState.inputInfo.token != nullptr;
Robert Carr720e5062018-07-30 17:45:14 -07002370}
2371
chaviw3e727cd2019-01-31 13:41:05 -08002372bool Layer::canReceiveInput() const {
Vishnu Nair82353e92019-09-12 12:38:47 -07002373 return !isHiddenByPolicy();
chaviw3e727cd2019-01-31 13:41:05 -08002374}
2375
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002376compositionengine::OutputLayer* Layer::findOutputLayerForDisplay(
2377 const sp<const DisplayDevice>& display) const {
Lloyd Piquede196652020-01-22 17:29:58 -08002378 return display->getCompositionDisplay()->getOutputLayerForLayer(getCompositionEngineLayerFE());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08002379}
2380
Lloyd Piquea2468662019-03-07 21:31:06 -08002381Region Layer::debugGetVisibleRegionOnDefaultDisplay() const {
2382 sp<DisplayDevice> displayDevice = mFlinger->getDefaultDisplayDeviceLocked();
2383 if (displayDevice == nullptr) {
2384 return {};
2385 }
2386
2387 auto outputLayer = findOutputLayerForDisplay(displayDevice);
2388 if (outputLayer == nullptr) {
2389 return {};
2390 }
2391
2392 return outputLayer->getState().visibleRegion;
2393}
2394
chaviwb4c6e582019-08-16 14:35:07 -07002395void Layer::setInitialValuesForClone(const sp<Layer>& clonedFrom) {
2396 // copy drawing state from cloned layer
2397 mDrawingState = clonedFrom->mDrawingState;
2398 mClonedFrom = clonedFrom;
chaviwb4c6e582019-08-16 14:35:07 -07002399}
chaviw74b03172019-08-19 11:09:03 -07002400
2401void Layer::updateMirrorInfo() {
2402 if (mClonedChild == nullptr || !mClonedChild->isClonedFromAlive()) {
2403 // If mClonedChild is null, there is nothing to mirror. If isClonedFromAlive returns false,
2404 // it means that there is a clone, but the layer it was cloned from has been destroyed. In
2405 // that case, we want to delete the reference to the clone since we want it to get
2406 // destroyed. The root, this layer, will still be around since the client can continue
2407 // to hold a reference, but no cloned layers will be displayed.
2408 mClonedChild = nullptr;
2409 return;
2410 }
2411
2412 std::map<sp<Layer>, sp<Layer>> clonedLayersMap;
2413 // If the real layer exists and is in current state, add the clone as a child of the root.
2414 // There's no need to remove from drawingState when the layer is offscreen since currentState is
2415 // copied to drawingState for the root layer. So the clonedChild is always removed from
2416 // drawingState and then needs to be added back each traversal.
2417 if (!mClonedChild->getClonedFrom()->isRemovedFromCurrentState()) {
2418 addChildToDrawing(mClonedChild);
2419 }
2420
2421 mClonedChild->updateClonedDrawingState(clonedLayersMap);
2422 mClonedChild->updateClonedChildren(this, clonedLayersMap);
2423 mClonedChild->updateClonedRelatives(clonedLayersMap);
2424}
2425
2426void Layer::updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2427 // If the layer the clone was cloned from is alive, copy the content of the drawingState
2428 // to the clone. If the real layer is no longer alive, continue traversing the children
2429 // since we may be able to pull out other children that are still alive.
2430 if (isClonedFromAlive()) {
2431 sp<Layer> clonedFrom = getClonedFrom();
2432 mDrawingState = clonedFrom->mDrawingState;
chaviw74b03172019-08-19 11:09:03 -07002433 clonedLayersMap.emplace(clonedFrom, this);
2434 }
2435
2436 // The clone layer may have children in drawingState since they may have been created and
2437 // added from a previous request to updateMirorInfo. This is to ensure we don't recreate clones
2438 // that already exist, since we can just re-use them.
2439 // The drawingChildren will not get overwritten by the currentChildren since the clones are
2440 // not updated in the regular traversal. They are skipped since the root will lose the
2441 // reference to them when it copies its currentChildren to drawing.
2442 for (sp<Layer>& child : mDrawingChildren) {
2443 child->updateClonedDrawingState(clonedLayersMap);
2444 }
2445}
2446
2447void Layer::updateClonedChildren(const sp<Layer>& mirrorRoot,
2448 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2449 mDrawingChildren.clear();
2450
2451 if (!isClonedFromAlive()) {
2452 return;
2453 }
2454
2455 sp<Layer> clonedFrom = getClonedFrom();
2456 for (sp<Layer>& child : clonedFrom->mDrawingChildren) {
2457 if (child == mirrorRoot) {
2458 // This is to avoid cyclical mirroring.
2459 continue;
2460 }
2461 sp<Layer> clonedChild = clonedLayersMap[child];
2462 if (clonedChild == nullptr) {
2463 clonedChild = child->createClone();
2464 clonedLayersMap[child] = clonedChild;
2465 }
2466 addChildToDrawing(clonedChild);
2467 clonedChild->updateClonedChildren(mirrorRoot, clonedLayersMap);
2468 }
2469}
2470
chaviwaf87b3e2019-10-01 16:59:28 -07002471void Layer::updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
2472 auto cropLayer = mDrawingState.touchableRegionCrop.promote();
2473 if (cropLayer != nullptr) {
2474 if (clonedLayersMap.count(cropLayer) == 0) {
2475 // Real layer had a crop layer but it's not in the cloned hierarchy. Just set to
2476 // self as crop layer to avoid going outside bounds.
2477 mDrawingState.touchableRegionCrop = this;
2478 } else {
2479 const sp<Layer>& clonedCropLayer = clonedLayersMap.at(cropLayer);
2480 mDrawingState.touchableRegionCrop = clonedCropLayer;
2481 }
2482 }
2483 // Cloned layers shouldn't handle watch outside since their z order is not determined by
2484 // WM or the client.
2485 mDrawingState.inputInfo.layoutParamsFlags &= ~InputWindowInfo::FLAG_WATCH_OUTSIDE_TOUCH;
2486}
2487
2488void Layer::updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
chaviw74b03172019-08-19 11:09:03 -07002489 mDrawingState.zOrderRelativeOf = nullptr;
2490 mDrawingState.zOrderRelatives.clear();
2491
2492 if (!isClonedFromAlive()) {
2493 return;
2494 }
2495
chaviwaf87b3e2019-10-01 16:59:28 -07002496 const sp<Layer>& clonedFrom = getClonedFrom();
chaviw74b03172019-08-19 11:09:03 -07002497 for (wp<Layer>& relativeWeak : clonedFrom->mDrawingState.zOrderRelatives) {
chaviwaf87b3e2019-10-01 16:59:28 -07002498 const sp<Layer>& relative = relativeWeak.promote();
2499 if (clonedLayersMap.count(relative) > 0) {
2500 auto& clonedRelative = clonedLayersMap.at(relative);
chaviw74b03172019-08-19 11:09:03 -07002501 mDrawingState.zOrderRelatives.add(clonedRelative);
2502 }
2503 }
2504
2505 // Check if the relativeLayer for the real layer is part of the cloned hierarchy.
2506 // It's possible that the layer it's relative to is outside the requested cloned hierarchy.
2507 // In that case, we treat the layer as if the relativeOf has been removed. This way, it will
2508 // still traverse the children, but the layer with the missing relativeOf will not be shown
2509 // on screen.
chaviwaf87b3e2019-10-01 16:59:28 -07002510 const sp<Layer>& relativeOf = clonedFrom->mDrawingState.zOrderRelativeOf.promote();
2511 if (clonedLayersMap.count(relativeOf) > 0) {
2512 const sp<Layer>& clonedRelativeOf = clonedLayersMap.at(relativeOf);
chaviw74b03172019-08-19 11:09:03 -07002513 mDrawingState.zOrderRelativeOf = clonedRelativeOf;
2514 }
2515
chaviwaf87b3e2019-10-01 16:59:28 -07002516 updateClonedInputInfo(clonedLayersMap);
2517
chaviw74b03172019-08-19 11:09:03 -07002518 for (sp<Layer>& child : mDrawingChildren) {
2519 child->updateClonedRelatives(clonedLayersMap);
2520 }
2521}
2522
2523void Layer::addChildToDrawing(const sp<Layer>& layer) {
2524 mDrawingChildren.add(layer);
2525 layer->mDrawingParent = this;
2526}
2527
Steven Thomas62a4cf82020-01-31 12:04:03 -08002528Layer::FrameRateCompatibility Layer::FrameRate::convertCompatibility(int8_t compatibility) {
2529 switch (compatibility) {
2530 case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_DEFAULT:
2531 return FrameRateCompatibility::Default;
2532 case ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_FIXED_SOURCE:
2533 return FrameRateCompatibility::ExactOrMultiple;
2534 default:
2535 LOG_ALWAYS_FATAL("Invalid frame rate compatibility value %d", compatibility);
2536 return FrameRateCompatibility::Default;
2537 }
2538}
2539
Mathias Agopian13127d82013-03-05 17:47:11 -08002540// ---------------------------------------------------------------------------
2541
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002542}; // namespace android
Mathias Agopian3f844832013-08-07 21:24:32 -07002543
2544#if defined(__gl_h_)
2545#error "don't include gl/gl.h in this file"
2546#endif
2547
2548#if defined(__gl2_h_)
2549#error "don't include gl2/gl2.h in this file"
2550#endif
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -08002551
2552// TODO(b/129481165): remove the #pragma below and fix conversion issues
2553#pragma clang diagnostic pop // ignored "-Wconversion"