blob: 72f6de3710a7afd9669c14d894c55b1bb5212086 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_LAYER_H
18#define ANDROID_LAYER_H
19
Lloyd Piquefeb73d72018-12-04 17:23:44 -080020#include <compositionengine/LayerFE.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070021#include <gui/BufferQueue.h>
22#include <gui/ISurfaceComposerClient.h>
23#include <gui/LayerState.h>
Robert Carr720e5062018-07-30 17:45:14 -070024#include <input/InputWindow.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070025#include <layerproto/LayerProtoHeader.h>
26#include <math/vec4.h>
27#include <renderengine/Mesh.h>
28#include <renderengine/Texture.h>
Alec Mouri1c8d7202019-06-01 18:51:35 -070029#include <sys/types.h>
Dan Stoza80d61162017-12-20 15:57:52 -080030#include <ui/FloatRect.h>
Svetoslavd85084b2014-03-20 10:28:31 -070031#include <ui/FrameStats.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080032#include <ui/GraphicBuffer.h>
33#include <ui/PixelFormat.h>
34#include <ui/Region.h>
Peiyong Linefefaac2018-08-17 12:27:51 -070035#include <ui/Transform.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070036#include <utils/RefBase.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070037#include <utils/Timers.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080038
Robert Carrcdf83202018-03-07 12:48:34 -080039#include <cstdint>
Peiyong Lincbc184f2018-08-22 13:24:10 -070040#include <list>
Dominik Laskowski075d3172018-05-24 15:50:06 -070041#include <optional>
Peiyong Lincbc184f2018-08-22 13:24:10 -070042#include <vector>
Dan Stoza7dde5992015-05-22 09:51:44 -070043
Mathias Agopian13127d82013-03-05 17:47:11 -080044#include "Client.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070045#include "ClientCache.h"
46#include "DisplayHardware/ComposerHal.h"
47#include "DisplayHardware/HWComposer.h"
David Sodman41fdfc92017-11-06 16:09:56 -080048#include "FrameTracker.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070049#include "LayerVector.h"
Dan Stozab9b08832014-03-13 11:55:57 -070050#include "MonitoredProducer.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070051#include "RenderArea.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080052#include "SurfaceFlinger.h"
Marissa Walle2ffb422018-10-12 11:33:52 -070053#include "TransactionCompletedThread.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080054
chaviw1d044282017-09-27 12:19:28 -070055using namespace android::surfaceflinger;
56
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080057namespace android {
58
59// ---------------------------------------------------------------------------
60
Mathias Agopian1f7bec62010-06-25 18:02:21 -070061class Client;
Mathias Agopian3e25fd82013-04-22 17:52:16 +020062class Colorizer;
Mathias Agopian13127d82013-03-05 17:47:11 -080063class DisplayDevice;
64class GraphicBuffer;
65class SurfaceFlinger;
Kalle Raitaa099a242017-01-11 11:17:29 -080066class LayerDebugInfo;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067
Lloyd Piquefeb73d72018-12-04 17:23:44 -080068namespace compositionengine {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080069class OutputLayer;
Lloyd Piquea83776c2019-01-29 18:42:32 -080070struct LayerFECompositionState;
Lloyd Piquefeb73d72018-12-04 17:23:44 -080071}
72
Lloyd Pique4dccc412018-01-22 17:21:36 -080073namespace impl {
74class SurfaceInterceptor;
75}
76
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080077// ---------------------------------------------------------------------------
78
Lloyd Pique42ab75e2018-09-12 20:46:03 -070079struct LayerCreationArgs {
chaviwde94d0f2020-01-22 13:11:25 -080080 LayerCreationArgs(SurfaceFlinger* flinger, const sp<Client> client, std::string name,
Vishnu Nair0f085c62019-08-30 08:49:12 -070081 uint32_t w, uint32_t h, uint32_t flags, LayerMetadata metadata);
Lloyd Pique42ab75e2018-09-12 20:46:03 -070082
83 SurfaceFlinger* flinger;
chaviwde94d0f2020-01-22 13:11:25 -080084 const sp<Client> client;
Dominik Laskowski87a07e42019-10-10 20:38:02 -070085 std::string name;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070086 uint32_t w;
87 uint32_t h;
88 uint32_t flags;
Evan Roskya1f1e152019-01-24 16:17:46 -080089 LayerMetadata metadata;
Vishnu Nair0f085c62019-08-30 08:49:12 -070090 pid_t callingPid;
91 uid_t callingUid;
chaviwb4c6e582019-08-16 14:35:07 -070092 sp<const DisplayDevice> displayDevice;
93 uint32_t textureName;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070094};
95
Lloyd Piquede196652020-01-22 17:29:58 -080096class Layer : public virtual RefBase, compositionengine::LayerFE {
Lloyd Piquef1c675b2018-09-12 20:45:39 -070097 static std::atomic<int32_t> sSequence;
Ana Krulecc84d09b2019-11-02 23:10:29 +010098 static constexpr int32_t PRIORITY_UNSET = -1;
Mathias Agopian13127d82013-03-05 17:47:11 -080099
Mathias Agopiand606de62010-05-10 20:06:11 -0700100public:
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700101 mutable bool contentDirty{false};
Dan Stozaee44edd2015-03-23 15:50:23 -0700102 Region surfaceDamageRegion;
Andy McFadden4df87bd2014-04-21 18:08:54 -0700103
104 // Layer serial number. This gives layers an explicit ordering, so we
105 // have a stable sort order when their layer stack and Z-order are
106 // the same.
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700107 int32_t sequence{sSequence++};
Mathias Agopian13127d82013-03-05 17:47:11 -0800108
109 enum { // flags for doTransaction()
110 eDontUpdateGeometryState = 0x00000001,
111 eVisibleRegion = 0x00000002,
Robert Carr720e5062018-07-30 17:45:14 -0700112 eInputInfoChanged = 0x00000004
Mathias Agopian13127d82013-03-05 17:47:11 -0800113 };
114
115 struct Geometry {
116 uint32_t w;
117 uint32_t h;
Peiyong Linefefaac2018-08-17 12:27:51 -0700118 ui::Transform transform;
Robert Carr3dcabfa2016-03-01 18:36:58 -0800119
David Sodman41fdfc92017-11-06 16:09:56 -0800120 inline bool operator==(const Geometry& rhs) const {
121 return (w == rhs.w && h == rhs.h) && (transform.tx() == rhs.transform.tx()) &&
Robert Carr99e27f02016-06-16 15:18:02 -0700122 (transform.ty() == rhs.transform.ty());
Mathias Agopian13127d82013-03-05 17:47:11 -0800123 }
David Sodman41fdfc92017-11-06 16:09:56 -0800124 inline bool operator!=(const Geometry& rhs) const { return !operator==(rhs); }
Mathias Agopian13127d82013-03-05 17:47:11 -0800125 };
126
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700127 struct RoundedCornerState {
128 RoundedCornerState() = default;
129 RoundedCornerState(FloatRect cropRect, float radius)
130 : cropRect(cropRect), radius(radius) {}
131
132 // Rounded rectangle in local layer coordinate space.
133 FloatRect cropRect = FloatRect();
134 // Radius of the rounded rectangle.
135 float radius = 0.0f;
136 };
137
Ady Abraham71c437d2020-01-31 15:56:57 -0800138 // FrameRateCompatibility specifies how we should interpret the frame rate associated with
139 // the layer.
140 enum class FrameRateCompatibility {
141 Default, // Layer didn't specify any specific handling strategy
142
143 ExactOrMultiple, // Layer needs the exact frame rate (or a multiple of it) to present the
144 // content properly. Any other value will result in a pull down.
145
146 NoVote, // Layer doesn't have any requirements for the refresh rate and
147 // should not be considered when the display refresh rate is determined.
148 };
149
150 // Encapsulates the frame rate and compatibility of the layer. This information will be used
151 // when the display refresh rate is determined.
152 struct FrameRate {
153 float rate;
154 FrameRateCompatibility type;
155
156 FrameRate() : rate(0), type(FrameRateCompatibility::Default) {}
157 FrameRate(float rate, FrameRateCompatibility type) : rate(rate), type(type) {}
158
159 bool operator==(const FrameRate& other) const {
160 return rate == other.rate && type == other.type;
161 }
162
163 bool operator!=(const FrameRate& other) const { return !(*this == other); }
Steven Thomas62a4cf82020-01-31 12:04:03 -0800164
165 // Convert an ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value to a
166 // Layer::FrameRateCompatibility. Logs fatal if the compatibility value is invalid.
167 static FrameRateCompatibility convertCompatibility(int8_t compatibility);
Ady Abraham71c437d2020-01-31 15:56:57 -0800168 };
169
Mathias Agopian13127d82013-03-05 17:47:11 -0800170 struct State {
Marissa Wallf58c14b2018-07-24 10:50:43 -0700171 Geometry active_legacy;
172 Geometry requested_legacy;
Robert Carrae060832016-11-28 10:51:00 -0800173 int32_t z;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800174
175 // The identifier of the layer stack this layer belongs to. A layer can
176 // only be associated to a single layer stack. A layer stack is a
177 // z-ordered group of layers which can be associated to one or more
178 // displays. Using the same layer stack on different displays is a way
179 // to achieve mirroring.
Mathias Agopian13127d82013-03-05 17:47:11 -0800180 uint32_t layerStack;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800181
Mathias Agopian13127d82013-03-05 17:47:11 -0800182 uint8_t flags;
183 uint8_t reserved[2];
184 int32_t sequence; // changes when visible regions can change
Dan Stoza7dde5992015-05-22 09:51:44 -0700185 bool modified;
186
Fabien Sanglard4ed383c2016-12-13 14:02:41 -0800187 // Crop is expressed in layer space coordinate.
Marissa Wallf58c14b2018-07-24 10:50:43 -0700188 Rect crop_legacy;
189 Rect requestedCrop_legacy;
Robert Carr99e27f02016-06-16 15:18:02 -0700190
Robert Carr0d480722017-01-10 16:42:54 -0800191 // If set, defers this state update until the identified Layer
Dan Stoza7dde5992015-05-22 09:51:44 -0700192 // receives a frame with the given frameNumber
Marissa Wallf58c14b2018-07-24 10:50:43 -0700193 wp<Layer> barrierLayer_legacy;
194 uint64_t frameNumber_legacy;
Dan Stoza7dde5992015-05-22 09:51:44 -0700195
Mathias Agopian2ca79392013-04-02 18:30:32 -0700196 // the transparentRegion hint is a bit special, it's latched only
197 // when we receive a buffer -- this is because it's "content"
198 // dependent.
Marissa Wallf58c14b2018-07-24 10:50:43 -0700199 Region activeTransparentRegion_legacy;
200 Region requestedTransparentRegion_legacy;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500201
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800202 LayerMetadata metadata;
Robert Carrdb66e622017-04-10 16:55:57 -0700203
204 // If non-null, a Surface this Surface's Z-order is interpreted relative to.
205 wp<Layer> zOrderRelativeOf;
chaviwe5ac40f2019-09-24 16:36:55 -0700206 bool isRelativeOf{false};
Robert Carrdb66e622017-04-10 16:55:57 -0700207
208 // A list of surfaces whose Z-order is interpreted relative to ours.
209 SortedVector<wp<Layer>> zOrderRelatives;
chaviw13fdc492017-06-27 12:40:18 -0700210
211 half4 color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700212 float cornerRadius;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800213 int backgroundBlurRadius;
Marissa Wall61c58622018-07-18 10:12:20 -0700214
Robert Carr720e5062018-07-30 17:45:14 -0700215 bool inputInfoChanged;
216 InputWindowInfo inputInfo;
Vishnu Nair6fabeec2019-03-12 13:42:49 -0700217 wp<Layer> touchableRegionCrop;
Robert Carr720e5062018-07-30 17:45:14 -0700218
Vishnu Nairfa247b12020-02-11 08:58:26 -0800219 // dataspace is only used by BufferStateLayer and EffectLayer
Valerie Haub153bab2019-03-05 10:47:28 -0800220 ui::Dataspace dataspace;
221
Marissa Wall61c58622018-07-18 10:12:20 -0700222 // The fields below this point are only used by BufferStateLayer
Valerie Hau134651a2020-01-28 16:21:22 -0800223 uint64_t frameNumber;
Marissa Wall61c58622018-07-18 10:12:20 -0700224 Geometry active;
225
226 uint32_t transform;
227 bool transformToDisplayInverse;
228
229 Rect crop;
230 Region transparentRegionHint;
231
232 sp<GraphicBuffer> buffer;
Marissa Wall947d34e2019-03-29 14:03:53 -0700233 client_cache_t clientCacheId;
Marissa Wall61c58622018-07-18 10:12:20 -0700234 sp<Fence> acquireFence;
Marissa Wall61c58622018-07-18 10:12:20 -0700235 HdrMetadata hdrMetadata;
236 Region surfaceDamageRegion;
237 int32_t api;
238
239 sp<NativeHandle> sidebandStream;
Peiyong Lind3788632018-09-18 16:01:31 -0700240 mat4 colorTransform;
Peiyong Lin747321c2018-10-01 10:03:11 -0700241 bool hasColorTransform;
Marissa Walle2ffb422018-10-12 11:33:52 -0700242
Valerie Haua72e2812019-01-23 13:40:39 -0800243 // pointer to background color layer that, if set, appears below the buffer state layer
244 // and the buffer state layer's children. Z order will be set to
245 // INT_MIN
246 sp<Layer> bgColorLayer;
Valerie Haued54efa2019-01-11 20:03:14 -0800247
Marissa Walle2ffb422018-10-12 11:33:52 -0700248 // The deque of callback handles for this frame. The back of the deque contains the most
249 // recent callback handle.
250 std::deque<sp<CallbackHandle>> callbackHandles;
Peiyong Linc502cb72019-03-01 15:00:23 -0800251 bool colorSpaceAgnostic;
chaviwfa67b552019-08-12 16:51:55 -0700252 nsecs_t desiredPresentTime = -1;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800253
254 // Length of the cast shadow. If the radius is > 0, a shadow of length shadowRadius will
255 // be rendered around the layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700256 float shadowRadius;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100257
258 // Priority of the layer assigned by Window Manager.
259 int32_t frameRateSelectionPriority;
Steven Thomas3172e202020-01-06 19:25:30 -0800260
Ady Abraham71c437d2020-01-31 15:56:57 -0800261 FrameRate frameRate;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700262
263 // Indicates whether parents / children of this layer had set FrameRate
264 bool treeHasFrameRateVote;
Mathias Agopian13127d82013-03-05 17:47:11 -0800265 };
266
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700267 explicit Layer(const LayerCreationArgs& args);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700268 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800269
Dominik Laskowski75848362019-11-11 17:57:20 -0800270 void onFirstRef() override;
271
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700272 int getWindowType() const { return mWindowType; }
273
Chia-I Wuab0c3192017-08-01 11:29:00 -0700274 void setPrimaryDisplayOnly() { mPrimaryDisplayOnly = true; }
Lloyd Piqueef36b002019-01-23 17:52:04 -0800275 bool getPrimaryDisplayOnly() const { return mPrimaryDisplayOnly; }
Chia-I Wuab0c3192017-08-01 11:29:00 -0700276
Robert Carr7bf247e2017-05-18 14:02:49 -0700277 // ------------------------------------------------------------------------
278 // Geometry setting functions.
279 //
280 // The following group of functions are used to specify the layers
281 // bounds, and the mapping of the texture on to those bounds. According
282 // to various settings changes to them may apply immediately, or be delayed until
283 // a pending resize is completed by the producer submitting a buffer. For example
284 // if we were to change the buffer size, and update the matrix ahead of the
285 // new buffer arriving, then we would be stretching the buffer to a different
286 // aspect before and after the buffer arriving, which probably isn't what we wanted.
287 //
288 // The first set of geometry functions are controlled by the scaling mode, described
289 // in window.h. The scaling mode may be set by the client, as it submits buffers.
290 // This value may be overriden through SurfaceControl, with setOverrideScalingMode.
291 //
292 // Put simply, if our scaling mode is SCALING_MODE_FREEZE, then
293 // matrix updates will not be applied while a resize is pending
294 // and the size and transform will remain in their previous state
295 // until a new buffer is submitted. If the scaling mode is another value
296 // then the old-buffer will immediately be scaled to the pending size
297 // and the new matrix will be immediately applied following this scaling
298 // transformation.
Robert Carr8d5227b2017-03-16 15:41:03 -0700299
Robert Carr7bf247e2017-05-18 14:02:49 -0700300 // Set the default buffer size for the assosciated Producer, in pixels. This is
301 // also the rendered size of the layer prior to any transformations. Parent
302 // or local matrix transformations will not affect the size of the buffer,
303 // but may affect it's on-screen size or clipping.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800304 virtual bool setSize(uint32_t w, uint32_t h);
Robert Carr7bf247e2017-05-18 14:02:49 -0700305 // Set a 2x2 transformation matrix on the layer. This transform
306 // will be applied after parent transforms, but before any final
307 // producer specified transform.
Marissa Wall61c58622018-07-18 10:12:20 -0700308 virtual bool setMatrix(const layer_state_t::matrix22_t& matrix,
309 bool allowNonRectPreservingTransforms);
Robert Carr7bf247e2017-05-18 14:02:49 -0700310
311 // This second set of geometry attributes are controlled by
312 // setGeometryAppliesWithResize, and their default mode is to be
313 // immediate. If setGeometryAppliesWithResize is specified
314 // while a resize is pending, then update of these attributes will
315 // be delayed until the resize completes.
316
317 // setPosition operates in parent buffer space (pre parent-transform) or display
318 // space for top-level layers.
chaviw214c89d2019-09-04 16:03:53 -0700319 virtual bool setPosition(float x, float y);
Robert Carr7bf247e2017-05-18 14:02:49 -0700320 // Buffer space
chaviw214c89d2019-09-04 16:03:53 -0700321 virtual bool setCrop_legacy(const Rect& crop);
Robert Carr8d5227b2017-03-16 15:41:03 -0700322
Robert Carr7bf247e2017-05-18 14:02:49 -0700323 // TODO(b/38182121): Could we eliminate the various latching modes by
324 // using the layer hierarchy?
325 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800326 virtual bool setLayer(int32_t z);
327 virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carrdb66e622017-04-10 16:55:57 -0700328
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800329 virtual bool setAlpha(float alpha);
Valerie Haudd0b7572019-01-29 14:59:27 -0800330 virtual bool setColor(const half3& /*color*/) { return false; };
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700331
332 // Set rounded corner radius for this layer and its children.
333 //
334 // We only support 1 radius per layer in the hierarchy, where parent layers have precedence.
335 // The shape of the rounded corner rectangle is specified by the crop rectangle of the layer
336 // from which we inferred the rounded corner radius.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800337 virtual bool setCornerRadius(float cornerRadius);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800338 // When non-zero, everything below this layer will be blurred by backgroundBlurRadius, which
339 // is specified in pixels.
340 virtual bool setBackgroundBlurRadius(int backgroundBlurRadius);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800341 virtual bool setTransparentRegionHint(const Region& transparent);
342 virtual bool setFlags(uint8_t flags, uint8_t mask);
343 virtual bool setLayerStack(uint32_t layerStack);
344 virtual uint32_t getLayerStack() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700345 virtual void deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle,
346 uint64_t frameNumber);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800347 virtual void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber);
348 virtual bool setOverrideScalingMode(int32_t overrideScalingMode);
Evan Roskyef876c92019-01-25 17:46:06 -0800349 virtual bool setMetadata(const LayerMetadata& data);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700350 bool reparentChildren(const sp<IBinder>& newParentHandle);
351 void reparentChildren(const sp<Layer>& newParent);
Marissa Wall61c58622018-07-18 10:12:20 -0700352 virtual void setChildrenDrawingParent(const sp<Layer>& layer);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800353 virtual bool reparent(const sp<IBinder>& newParentHandle);
Marissa Wall61c58622018-07-18 10:12:20 -0700354 virtual bool detachChildren();
chaviw5aedec92018-10-22 10:40:38 -0700355 bool attachChildren();
356 bool isLayerDetached() const { return mLayerDetached; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800357 virtual bool setColorTransform(const mat4& matrix);
358 virtual mat4 getColorTransform() const;
359 virtual bool hasColorTransform() const;
Peiyong Linc502cb72019-03-01 15:00:23 -0800360 virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; }
Marissa Wall61c58622018-07-18 10:12:20 -0700361
362 // Used only to set BufferStateLayer state
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800363 virtual bool setTransform(uint32_t /*transform*/) { return false; };
364 virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };
365 virtual bool setCrop(const Rect& /*crop*/) { return false; };
366 virtual bool setFrame(const Rect& /*frame*/) { return false; };
Valerie Haubf784642020-01-29 07:25:23 -0800367 virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/, const sp<Fence>& /*acquireFence*/,
368 nsecs_t /*postTime*/, nsecs_t /*desiredPresentTime*/,
Marissa Wall947d34e2019-03-29 14:03:53 -0700369 const client_cache_t& /*clientCacheId*/) {
Ady Abraham09bd3922019-04-08 10:44:56 -0700370 return false;
Marissa Wall947d34e2019-03-29 14:03:53 -0700371 };
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800372 virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };
373 virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };
374 virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };
375 virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) { return false; };
376 virtual bool setApi(int32_t /*api*/) { return false; };
377 virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };
Marissa Walle2ffb422018-10-12 11:33:52 -0700378 virtual bool setTransactionCompletedListeners(
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800379 const std::vector<sp<CallbackHandle>>& /*handles*/) {
Marissa Walle2ffb422018-10-12 11:33:52 -0700380 return false;
381 };
Valerie Hau7618b232020-01-09 16:03:08 -0800382 virtual void forceSendCallbacks() {}
Valerie Hau871d6352020-01-29 08:44:02 -0800383 virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/,
384 nsecs_t /*requestedPresentTime*/) {
385 return false;
386 }
Valerie Haudd0b7572019-01-29 14:59:27 -0800387 virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace);
Peiyong Linc502cb72019-03-01 15:00:23 -0800388 virtual bool setColorSpaceAgnostic(const bool agnostic);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700389 bool setShadowRadius(float shadowRadius);
Ana Krulecc84d09b2019-11-02 23:10:29 +0100390 virtual bool setFrameRateSelectionPriority(int32_t priority);
391 // If the variable is not set on the layer, it traverses up the tree to inherit the frame
392 // rate priority from its parent.
393 virtual int32_t getFrameRateSelectionPriority() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800394
chaviw4244e032019-09-04 11:27:49 -0700395 virtual ui::Dataspace getDataSpace() const { return ui::Dataspace::UNKNOWN; }
Chia-I Wu01591c92018-05-22 12:03:00 -0700396
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800397 // Before color management is introduced, contents on Android have to be
398 // desaturated in order to match what they appears like visually.
399 // With color management, these contents will appear desaturated, thus
400 // needed to be saturated so that they match what they are designed for
Chia-I Wu11481472018-05-04 10:43:19 -0700401 // visually.
402 bool isLegacyDataSpace() const;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800403
Lloyd Piquede196652020-01-22 17:29:58 -0800404 virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const;
405 virtual compositionengine::LayerFECompositionState* editCompositionState();
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800406
Dan Stozaee44edd2015-03-23 15:50:23 -0700407 // If we have received a new buffer this frame, we will pass its surface
408 // damage down to hardware composer. Otherwise, we must send a region with
409 // one empty rect.
Robert Carr105e64b2018-03-07 12:47:50 -0800410 virtual void useSurfaceDamage() {}
411 virtual void useEmptyDamage() {}
Dan Stozaee44edd2015-03-23 15:50:23 -0700412
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800413 uint32_t getTransactionFlags() const { return mTransactionFlags; }
414 uint32_t getTransactionFlags(uint32_t flags);
415 uint32_t setTransactionFlags(uint32_t flags);
Mathias Agopian13127d82013-03-05 17:47:11 -0800416
Lloyd Piqueef36b002019-01-23 17:52:04 -0800417 // Deprecated, please use compositionengine::Output::belongsInOutput()
418 // instead.
419 // TODO(lpique): Move the remaining callers (screencap) to the new function.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800420 bool belongsToDisplay(uint32_t layerStack, bool isPrimaryDisplay) const {
Chia-I Wuab0c3192017-08-01 11:29:00 -0700421 return getLayerStack() == layerStack && (!mPrimaryDisplayOnly || isPrimaryDisplay);
422 }
423
Vishnu Nair4351ad52019-02-11 14:13:02 -0800424 FloatRect getBounds(const Region& activeTransparentRegion) const;
425 FloatRect getBounds() const;
426
427 // Compute bounds for the layer and cache the results.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700428 void computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float shadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800429
Vishnu Nairc652ff82019-03-15 12:48:54 -0700430 // Returns the buffer scale transform if a scaling mode is set.
431 ui::Transform getBufferScaleTransform() const;
432
Vishnu Nair4351ad52019-02-11 14:13:02 -0800433 // Get effective layer transform, taking into account all its parent transform with any
434 // scaling if the parent scaling more is not NATIVE_WINDOW_SCALING_MODE_FREEZE.
Vishnu Nairc652ff82019-03-15 12:48:54 -0700435 ui::Transform getTransformWithScale(const ui::Transform& bufferScaleTransform) const;
436
437 // Returns the bounds of the layer without any buffer scaling.
438 FloatRect getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800439
Pablo Ceballos40845df2016-01-25 17:41:15 -0800440 int32_t getSequence() const { return sequence; }
441
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700442 // For tracing.
443 // TODO: Replace with raw buffer id from buffer metadata when that becomes available.
444 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces
445 // creates its tracks by buffer id and has no way of associating a buffer back to the process
446 // that created it, the current implementation is only sufficient for cases where a buffer is
447 // only used within a single layer.
chaviwd62d3062019-09-04 14:48:02 -0700448 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; }
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700449
Mathias Agopian13127d82013-03-05 17:47:11 -0800450 // -----------------------------------------------------------------------
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700451 // Virtuals
chaviw8a01fa42019-08-19 12:39:31 -0700452
453 // Provide unique string for each class type in the Layer hierarchy
454 virtual const char* getType() const = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -0800455
Mathias Agopian13127d82013-03-05 17:47:11 -0800456 /*
457 * isOpaque - true if this surface is opaque
Andy McFadden4125a4f2014-01-29 17:17:11 -0800458 *
459 * This takes into account the buffer format (i.e. whether or not the
460 * pixel format includes an alpha channel) and the "opaque" flag set
461 * on the layer. It does not examine the current plane alpha value.
Mathias Agopian13127d82013-03-05 17:47:11 -0800462 */
Robert Carr105e64b2018-03-07 12:47:50 -0800463 virtual bool isOpaque(const Layer::State&) const { return false; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800464
465 /*
466 * isSecure - true if this surface is secure, that is if it prevents
467 * screenshots or VNC servers.
468 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800469 bool isSecure() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800470
471 /*
472 * isVisible - true if this layer is visible, false otherwise
473 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800474 virtual bool isVisible() const = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800475
Mathias Agopian13127d82013-03-05 17:47:11 -0800476 /*
Robert Carr1f0a16a2016-10-24 16:27:39 -0700477 * isHiddenByPolicy - true if this layer has been forced invisible.
478 * just because this is false, doesn't mean isVisible() is true.
479 * For example if this layer has no active buffer, it may not be hidden by
480 * policy, but it still can not be visible.
481 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800482 bool isHiddenByPolicy() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700483
484 /*
chaviw3e727cd2019-01-31 13:41:05 -0800485 * Returns whether this layer can receive input.
486 */
487 virtual bool canReceiveInput() const;
488
489 /*
Peiyong Linfb530cf2018-12-15 05:07:38 +0000490 * isProtected - true if the layer may contain protected content in the
491 * GRALLOC_USAGE_PROTECTED sense.
492 */
493 virtual bool isProtected() const { return false; }
494
495 /*
Mathias Agopian13127d82013-03-05 17:47:11 -0800496 * isFixedSize - true if content has a fixed size
497 */
Robert Carr105e64b2018-03-07 12:47:50 -0800498 virtual bool isFixedSize() const { return true; }
499
Lloyd Piquea83776c2019-01-29 18:42:32 -0800500 /*
501 * usesSourceCrop - true if content should use a source crop
502 */
503 virtual bool usesSourceCrop() const { return false; }
504
Dan Stoza436ccf32018-06-21 12:10:12 -0700505 // Most layers aren't created from the main thread, and therefore need to
506 // grab the SF state lock to access HWC, but ContainerLayer does, so we need
507 // to avoid grabbing the lock again to avoid deadlock
508 virtual bool isCreatedFromMainThread() const { return false; }
509
Robert Carr2e102c92018-10-23 12:11:15 -0700510 bool isRemovedFromCurrentState() const;
chaviw8b3871a2017-11-01 17:41:01 -0700511
chaviw6d89e2d2020-01-14 14:42:01 -0800512 LayerProto* writeToProto(LayersProto& layersProto,
Alec Mouri6b9e9912020-01-21 10:50:24 -0800513 uint32_t traceFlags = SurfaceTracing::TRACE_ALL,
514 const sp<const DisplayDevice>& device = nullptr) const;
chaviw08f3cb22020-01-13 13:17:21 -0800515
Vishnu Nair8406fd72019-07-30 11:29:31 -0700516 // Write states that are modified by the main thread. This includes drawing
517 // state as well as buffer data. This should be called in the main or tracing
518 // thread.
519 void writeToProtoDrawingState(LayerProto* layerInfo,
520 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700521 // Write drawing or current state. If writing current state, the caller should hold the
522 // external mStateLock. If writing drawing state, this function should be called on the
523 // main or tracing thread.
524 void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,
525 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800526
Marissa Wall61c58622018-07-18 10:12:20 -0700527 virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }
528 virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }
529 virtual uint32_t getActiveHeight(const Layer::State& s) const { return s.active_legacy.h; }
Peiyong Linefefaac2018-08-17 12:27:51 -0700530 virtual ui::Transform getActiveTransform(const Layer::State& s) const {
Marissa Wall61c58622018-07-18 10:12:20 -0700531 return s.active_legacy.transform;
532 }
533 virtual Region getActiveTransparentRegion(const Layer::State& s) const {
534 return s.activeTransparentRegion_legacy;
535 }
536 virtual Rect getCrop(const Layer::State& s) const { return s.crop_legacy; }
Lloyd Piquef16688f2019-02-19 17:47:57 -0800537 virtual bool needsFiltering(const sp<const DisplayDevice>&) const { return false; }
Peiyong Lin97067b02019-03-29 17:34:45 +0000538
chaviw74b03172019-08-19 11:09:03 -0700539 // This layer is not a clone, but it's the parent to the cloned hierarchy. The
540 // variable mClonedChild represents the top layer that will be cloned so this
541 // layer will be the parent of mClonedChild.
542 // The layers in the cloned hierarchy will match the lifetime of the real layers. That is
543 // if the real layer is destroyed, then the clone layer will also be destroyed.
544 sp<Layer> mClonedChild;
chaviwb4c6e582019-08-16 14:35:07 -0700545
chaviw74b03172019-08-19 11:09:03 -0700546 virtual sp<Layer> createClone() = 0;
547 void updateMirrorInfo();
548 virtual void updateCloneBufferInfo(){};
549
550protected:
Lloyd Piquede196652020-01-22 17:29:58 -0800551 sp<compositionengine::LayerFE> asLayerFE() const;
chaviw74b03172019-08-19 11:09:03 -0700552 sp<Layer> getClonedFrom() { return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr; }
553 bool isClone() { return mClonedFrom != nullptr; }
554 bool isClonedFromAlive() { return getClonedFrom() != nullptr; }
555
chaviwb4c6e582019-08-16 14:35:07 -0700556 virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
557
chaviw74b03172019-08-19 11:09:03 -0700558 void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
559 void updateClonedChildren(const sp<Layer>& mirrorRoot,
560 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
chaviwaf87b3e2019-10-01 16:59:28 -0700561 void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
chaviw74b03172019-08-19 11:09:03 -0700562 void addChildToDrawing(const sp<Layer>& layer);
chaviwaf87b3e2019-10-01 16:59:28 -0700563 void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800564 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
565 compositionengine::LayerFE::ClientCompositionTargetSettings&);
566 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareShadowClientComposition(
567 const LayerFE::LayerSettings& layerSettings, const Rect& displayViewport,
568 ui::Dataspace outputDataspace);
569 // Modifies the passed in layer settings to clear the contents. If the blackout flag is set,
570 // the settings clears the content with a solid black fill.
571 void prepareClearClientComposition(LayerFE::LayerSettings& layerSettings, bool blackout) const;
chaviw74b03172019-08-19 11:09:03 -0700572
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700573public:
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800574 /*
575 * compositionengine::LayerFE overrides
576 */
Lloyd Piquede196652020-01-22 17:29:58 -0800577 const compositionengine::LayerFECompositionState* getCompositionState() const override;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800578 bool onPreComposition(nsecs_t) override;
Lloyd Piquede196652020-01-22 17:29:58 -0800579 void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800580 std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList(
Lloyd Piquef16688f2019-02-19 17:47:57 -0800581 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800582 void onLayerDisplayed(const sp<Fence>& releaseFence) override;
Lloyd Piquea83776c2019-01-29 18:42:32 -0800583 const char* getDebugName() const override;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800584
Lloyd Piquea83776c2019-01-29 18:42:32 -0800585protected:
Lloyd Piquede196652020-01-22 17:29:58 -0800586 void prepareBasicGeometryCompositionState();
587 void prepareGeometryCompositionState();
588 virtual void preparePerFrameCompositionState();
589 void prepareCursorCompositionState();
Lloyd Piquea83776c2019-01-29 18:42:32 -0800590
591public:
Robert Carr105e64b2018-03-07 12:47:50 -0800592 virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {}
David Sodmaneb085e02017-10-05 18:49:04 -0700593
Chia-I Wu692e0832018-06-05 15:46:58 -0700594 virtual bool isHdrY410() const { return false; }
595
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800596 Hwc2::IComposerClient::Composition getCompositionType(
597 const sp<const DisplayDevice>& display) const;
598 bool getClearClientTarget(const sp<const DisplayDevice>& display) const;
Riley Andrews03414a12014-07-01 14:22:59 -0700599
Ana Krulec010d2192018-10-08 06:29:54 -0700600 virtual bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const { return false; }
Robert Carr105e64b2018-03-07 12:47:50 -0800601 virtual void setTransformHint(uint32_t /*orientation*/) const { }
Dan Stoza6b9454d2014-11-07 16:00:59 -0800602
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700603 /*
Dan Stozae77c7662016-05-13 11:37:28 -0700604 * called after composition.
605 * returns true if the layer latched a new buffer this frame.
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700606 */
Adithya Srinivasanb69e0762019-11-11 18:39:53 -0800607 virtual bool onPostComposition(sp<const DisplayDevice> /*displayDevice*/,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700608 const std::shared_ptr<FenceTime>& /*glDoneFence*/,
Robert Carr105e64b2018-03-07 12:47:50 -0800609 const std::shared_ptr<FenceTime>& /*presentFence*/,
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800610 const CompositorTiming& /*compositorTiming*/) {
Robert Carr105e64b2018-03-07 12:47:50 -0800611 return false;
612 }
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700613
Dan Stoza9e56aa02015-11-02 13:00:03 -0800614 // If a buffer was replaced this frame, release the former buffer
Robert Carr105e64b2018-03-07 12:47:50 -0800615 virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { }
616
Valerie Hau871d6352020-01-29 08:44:02 -0800617 virtual void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& /*glDoneFence*/,
618 const CompositorTiming& /*compositorTiming*/) {}
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700619 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700620 * doTransaction - process the transaction. This is a good place to figure
621 * out which attributes of the surface have changed.
622 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800623 uint32_t doTransaction(uint32_t transactionFlags);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700624
625 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700626 * latchBuffer - called each time the screen is redrawn and returns whether
627 * the visible regions need to be recomputed (this is a fairly heavy
628 * operation, so this should be set only if needed). Typically this is used
629 * to figure out if the content or size of a surface has changed.
630 */
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700631 virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
632 nsecs_t /*expectedPresentTime*/) {
633 return false;
Robert Carr105e64b2018-03-07 12:47:50 -0800634 }
635
636 virtual bool isBufferLatched() const { return false; }
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700637
chaviw49a108c2019-08-12 11:23:06 -0700638 virtual void latchAndReleaseBuffer() {}
639
Mathias Agopian13127d82013-03-05 17:47:11 -0800640 /*
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700641 * Remove relative z for the layer if its relative parent is not part of the
642 * provided layer tree.
643 */
644 void removeRelativeZ(const std::vector<Layer*>& layersInTree);
645
646 /*
647 * Remove from current state and mark for removal.
648 */
649 void removeFromCurrentState();
650
651 /*
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800652 * called with the state lock from a binder thread when the layer is
Chia-I Wuc6657022017-08-15 11:18:17 -0700653 * removed from the current list to the pending removal list
654 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800655 void onRemovedFromCurrentState();
Chia-I Wuc6657022017-08-15 11:18:17 -0700656
chaviw61626f22018-11-15 16:26:27 -0800657 /*
658 * Called when the layer is added back to the current state list.
659 */
660 void addToCurrentState();
661
Andy McFaddenbf974ab2012-12-04 16:51:15 -0800662 // Updates the transform hint in our SurfaceFlingerConsumer to match
Mathias Agopian84300952012-11-21 16:02:13 -0800663 // the current orientation of the display device.
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700664 void updateTransformHint(const sp<const DisplayDevice>& display) const;
Andy McFadden69052052012-09-14 16:10:11 -0700665
Mathias Agopian13127d82013-03-05 17:47:11 -0800666 /*
667 * returns the rectangle that crops the content of the layer and scales it
668 * to the layer's size.
669 */
chaviw4244e032019-09-04 11:27:49 -0700670 virtual Rect getBufferCrop() const { return Rect(); }
671
672 /*
673 * Returns the transform applied to the buffer.
674 */
675 virtual uint32_t getBufferTransform() const { return 0; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800676
chaviwd62d3062019-09-04 14:48:02 -0700677 virtual sp<GraphicBuffer> getBuffer() const { return nullptr; }
678
Eric Penner51c59cd2014-07-28 19:51:58 -0700679 /*
Marissa Wallfd668622018-05-10 10:21:13 -0700680 * Returns if a frame is ready
Eric Penner51c59cd2014-07-28 19:51:58 -0700681 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800682 virtual bool hasReadyFrame() const { return false; }
Eric Penner51c59cd2014-07-28 19:51:58 -0700683
Marissa Wallfd668622018-05-10 10:21:13 -0700684 virtual int32_t getQueuedFrameCount() const { return 0; }
Kalle Raitaa099a242017-01-11 11:17:29 -0800685
Dan Stoza9e56aa02015-11-02 13:00:03 -0800686 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800687 inline const State& getDrawingState() const { return mDrawingState; }
688 inline const State& getCurrentState() const { return mCurrentState; }
689 inline State& getCurrentState() { return mCurrentState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800690
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800691 LayerDebugInfo getLayerDebugInfo() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800692
693 /* always call base class first */
Yiwei Zhang5434a782018-12-05 18:06:32 -0800694 static void miniDumpHeader(std::string& result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800695 void miniDump(std::string& result, const sp<DisplayDevice>& display) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800696 void dumpFrameStats(std::string& result) const;
697 void dumpFrameEvents(std::string& result);
Vishnu Nair0f085c62019-08-30 08:49:12 -0700698 void dumpCallingUidPid(std::string& result) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700699 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700700 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700701 void getFrameStats(FrameStats* outStats) const;
Mathias Agopian1b5e1022010-04-20 17:55:49 -0700702
Robert Carr105e64b2018-03-07 12:47:50 -0800703 virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) {
704 return {};
705 }
Dan Stozae77c7662016-05-13 11:37:28 -0700706
Brian Anderson5ea5e592016-12-01 16:54:33 -0800707 void onDisconnect();
Brian Anderson3890c392016-07-25 12:48:08 -0700708 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
David Sodman41fdfc92017-11-06 16:09:56 -0800709 FrameEventHistoryDelta* outDelta);
Pablo Ceballosce796e72016-02-04 19:10:51 -0800710
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800711 virtual bool getTransformToDisplayInverse() const { return false; }
Robert Carr367c5682016-06-20 11:55:28 -0700712
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800713 ui::Transform getTransform() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700714
Robert Carr6452f122017-03-21 10:41:29 -0700715 // Returns the Alpha of the Surface, accounting for the Alpha
716 // of parent Surfaces in the hierarchy (alpha's will be multiplied
717 // down the hierarchy).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800718 half getAlpha() const;
719 half4 getColor() const;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800720 int32_t getBackgroundBlurRadius() const;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800721 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; };
Robert Carr6452f122017-03-21 10:41:29 -0700722
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700723 // Returns how rounded corners should be drawn for this layer.
724 // This will traverse the hierarchy until it reaches its root, finding topmost rounded
725 // corner definition and converting it into current layer's coordinates.
726 // As of now, only 1 corner radius per display list is supported. Subsequent ones will be
727 // ignored.
Valerie Hau92bf5482020-02-10 09:49:08 -0800728 virtual RoundedCornerState getRoundedCornerState() const;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700729
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800730 renderengine::ShadowSettings getShadowSettings(const Rect& viewport) const;
731
Edgar Arriaga844fa672020-01-16 14:21:42 -0800732 /**
733 * Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder
734 * which will not emit children who have relativeZOrder to another layer, this method
735 * just directly emits all children. It also emits them in no particular order.
736 * So this method is not suitable for graphical operations, as it doesn't represent
737 * the scene state, but it's also more efficient than traverseInZOrder and so useful for
738 * book-keeping.
739 */
740 void traverse(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor);
Dan Stoza412903f2017-04-27 13:42:17 -0700741 void traverseInReverseZOrder(LayerVector::StateSet stateSet,
742 const LayerVector::Visitor& visitor);
743 void traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700744
chaviw4b129c22018-04-09 16:19:43 -0700745 /**
746 * Traverse only children in z order, ignoring relative layers that are not children of the
747 * parent.
748 */
chaviwa76b2712017-09-20 12:02:26 -0700749 void traverseChildrenInZOrder(LayerVector::StateSet stateSet,
750 const LayerVector::Visitor& visitor);
751
Chia-I Wu98f1c102017-05-30 14:54:08 -0700752 size_t getChildrenCount() const;
Valerie Hauc5686802019-11-22 14:18:09 -0800753
754 // ONLY CALL THIS FROM THE LAYER DTOR!
755 // See b/141111965. We need to add current children to offscreen layers in
756 // the layer dtor so as not to dangle layers. Since the layer has not
757 // committed its transaction when the layer is destroyed, we must add
758 // current children. This is safe in the dtor as we will no longer update
759 // the current state, but should not be called anywhere else!
760 LayerVector& getCurrentChildren() { return mCurrentChildren; }
761
Robert Carr1f0a16a2016-10-24 16:27:39 -0700762 void addChild(const sp<Layer>& layer);
763 // Returns index if removed, or negative value otherwise
764 // for symmetry with Vector::remove
765 ssize_t removeChild(const sp<Layer>& layer);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700766 sp<Layer> getParent() const { return mCurrentParent.promote(); }
Robert Carr1f0a16a2016-10-24 16:27:39 -0700767 bool hasParent() const { return getParent() != nullptr; }
Vishnu Nair4351ad52019-02-11 14:13:02 -0800768 Rect getScreenBounds(bool reduceTransparentRegion = true) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700769 bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
Robert Carr503c7042017-09-27 15:06:08 -0700770 bool setChildRelativeLayer(const sp<Layer>& childLayer,
771 const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700772
773 // Copy the current list of children to the drawing state. Called by
774 // SurfaceFlinger to complete a transaction.
775 void commitChildList();
chaviw301b1d82019-11-06 13:15:09 -0800776 int32_t getZ(LayerVector::StateSet stateSet) const;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800777 virtual void pushPendingState();
David Sodman41fdfc92017-11-06 16:09:56 -0800778
Vishnu Nair88a11f22018-11-28 18:30:57 -0800779 /**
780 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing
781 * any buffer transformations. If the layer has no buffer then return INVALID_RECT.
782 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800783 virtual Rect getBufferSize(const Layer::State&) const { return Rect::INVALID_RECT; }
Vishnu Nair88a11f22018-11-28 18:30:57 -0800784
Vishnu Nair4351ad52019-02-11 14:13:02 -0800785 /**
786 * Returns the source bounds. If the bounds are not defined, it is inferred from the
787 * buffer size. Failing that, the bounds are determined from the passed in parent bounds.
788 * For the root layer, this is the display viewport size.
789 */
790 virtual FloatRect computeSourceBounds(const FloatRect& parentBounds) const {
791 return parentBounds;
792 }
793
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800794 compositionengine::OutputLayer* findOutputLayerForDisplay(
795 const sp<const DisplayDevice>& display) const;
796
Lloyd Piquea2468662019-03-07 21:31:06 -0800797 Region debugGetVisibleRegionOnDefaultDisplay() const;
798
Vishnu Nairefc42e22019-12-03 17:36:12 -0800799 /**
800 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
801 * INVALID_RECT if the layer has no buffer and no crop.
802 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer
803 * bounds are constrained by its parent bounds.
804 */
805 Rect getCroppedBufferSize(const Layer::State& s) const;
806
Steven Thomas62a4cf82020-01-31 12:04:03 -0800807 bool setFrameRate(FrameRate frameRate);
Ady Abraham60e42ea2020-03-09 19:17:31 -0700808 virtual FrameRate getFrameRateForLayerTree() const;
Steven Thomas3172e202020-01-06 19:25:30 -0800809
Mathias Agopian13127d82013-03-05 17:47:11 -0800810protected:
811 // constant
812 sp<SurfaceFlinger> mFlinger;
Mathias Agopian13127d82013-03-05 17:47:11 -0800813 /*
814 * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
815 * is called.
816 */
817 class LayerCleaner {
818 sp<SurfaceFlinger> mFlinger;
Robert Carr2e102c92018-10-23 12:11:15 -0700819 sp<Layer> mLayer;
David Sodman41fdfc92017-11-06 16:09:56 -0800820
Mathias Agopian13127d82013-03-05 17:47:11 -0800821 protected:
Irvel468051e2016-06-13 16:44:44 -0700822 ~LayerCleaner() {
823 // destroy client resources
Robert Carr2e102c92018-10-23 12:11:15 -0700824 mFlinger->onHandleDestroyed(mLayer);
Irvel468051e2016-06-13 16:44:44 -0700825 }
David Sodman41fdfc92017-11-06 16:09:56 -0800826
Mathias Agopian13127d82013-03-05 17:47:11 -0800827 public:
David Sodman41fdfc92017-11-06 16:09:56 -0800828 LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
829 : mFlinger(flinger), mLayer(layer) {}
Mathias Agopian13127d82013-03-05 17:47:11 -0800830 };
831
Lloyd Pique4dccc412018-01-22 17:21:36 -0800832 friend class impl::SurfaceInterceptor;
David Sodmaneb085e02017-10-05 18:49:04 -0700833
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700834 // For unit tests
835 friend class TestableSurfaceFlinger;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100836 friend class RefreshRateSelectionTest;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700837 friend class SetFrameRateTest;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700838
Valerie Haub153bab2019-03-05 10:47:28 -0800839 virtual void commitTransaction(const State& stateToCommit);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700840
Mathias Agopian3330b202009-10-05 17:07:12 -0700841 uint32_t getEffectiveUsage(uint32_t usage) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700842
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700843 /**
844 * Setup rounded corners coordinates of this layer, taking into account the layer bounds and
845 * crop coordinates, transforming them into layer space.
846 */
847 void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700848 void setParent(const sp<Layer>& layer);
Robert Carr29abff82017-12-04 13:51:20 -0800849 LayerVector makeTraversalList(LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800850 void addZOrderRelative(const wp<Layer>& relative);
851 void removeZOrderRelative(const wp<Layer>& relative);
Robert Carrdb66e622017-04-10 16:55:57 -0700852
David Sodman41fdfc92017-11-06 16:09:56 -0800853 class SyncPoint {
Dan Stoza7dde5992015-05-22 09:51:44 -0700854 public:
chaviw43cb3cb2019-05-31 15:23:41 -0700855 explicit SyncPoint(uint64_t frameNumber, wp<Layer> requestedSyncLayer)
856 : mFrameNumber(frameNumber),
857 mFrameIsAvailable(false),
858 mTransactionIsApplied(false),
859 mRequestedSyncLayer(requestedSyncLayer) {}
Dan Stoza7dde5992015-05-22 09:51:44 -0700860
David Sodman41fdfc92017-11-06 16:09:56 -0800861 uint64_t getFrameNumber() const { return mFrameNumber; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700862
David Sodman41fdfc92017-11-06 16:09:56 -0800863 bool frameIsAvailable() const { return mFrameIsAvailable; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700864
David Sodman41fdfc92017-11-06 16:09:56 -0800865 void setFrameAvailable() { mFrameIsAvailable = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700866
David Sodman41fdfc92017-11-06 16:09:56 -0800867 bool transactionIsApplied() const { return mTransactionIsApplied; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700868
David Sodman41fdfc92017-11-06 16:09:56 -0800869 void setTransactionApplied() { mTransactionIsApplied = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700870
chaviw43cb3cb2019-05-31 15:23:41 -0700871 sp<Layer> getRequestedSyncLayer() { return mRequestedSyncLayer.promote(); }
872
Dan Stoza7dde5992015-05-22 09:51:44 -0700873 private:
874 const uint64_t mFrameNumber;
875 std::atomic<bool> mFrameIsAvailable;
876 std::atomic<bool> mTransactionIsApplied;
chaviw43cb3cb2019-05-31 15:23:41 -0700877 wp<Layer> mRequestedSyncLayer;
Dan Stoza7dde5992015-05-22 09:51:44 -0700878 };
879
Dan Stozacac35382016-01-27 12:21:06 -0800880 // SyncPoints which will be signaled when the correct frame is at the head
881 // of the queue and dropped after the frame has been latched. Protected by
882 // mLocalSyncPointMutex.
883 Mutex mLocalSyncPointMutex;
Dan Stoza7dde5992015-05-22 09:51:44 -0700884 std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
885
Dan Stozacac35382016-01-27 12:21:06 -0800886 // SyncPoints which will be signaled and then dropped when the transaction
887 // is applied
Dan Stoza7dde5992015-05-22 09:51:44 -0700888 std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
889
Dan Stozacac35382016-01-27 12:21:06 -0800890 // Returns false if the relevant frame has already been latched
891 bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
Dan Stoza7dde5992015-05-22 09:51:44 -0700892
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800893 void popPendingState(State* stateToCommit);
894 virtual bool applyPendingStates(State* stateToCommit);
895 virtual uint32_t doTransactionResize(uint32_t flags, Layer::State* stateToCommit);
Robert Carrc3574f72016-03-24 12:19:32 -0700896
897 // Returns mCurrentScaling mode (originating from the
898 // Client) or mOverrideScalingMode mode (originating from
899 // the Surface Controller) if set.
Robert Carr105e64b2018-03-07 12:47:50 -0800900 virtual uint32_t getEffectiveScalingMode() const { return 0; }
David Sodman41fdfc92017-11-06 16:09:56 -0800901
Dan Stoza7dde5992015-05-22 09:51:44 -0700902public:
Irvel468051e2016-06-13 16:44:44 -0700903 /*
904 * The layer handle is just a BBinder object passed to the client
905 * (remote process) -- we don't keep any reference on our side such that
906 * the dtor is called when the remote side let go of its reference.
907 *
908 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
909 * this layer when the handle is destroyed.
910 */
911 class Handle : public BBinder, public LayerCleaner {
David Sodman41fdfc92017-11-06 16:09:56 -0800912 public:
913 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
914 : LayerCleaner(flinger, layer), owner(layer) {}
Irvel468051e2016-06-13 16:44:44 -0700915
David Sodman41fdfc92017-11-06 16:09:56 -0800916 wp<Layer> owner;
Irvel468051e2016-06-13 16:44:44 -0700917 };
918
Robert Carrc0df3122019-04-11 13:18:21 -0700919 // Creates a new handle each time, so we only expect
920 // this to be called once.
Irvel468051e2016-06-13 16:44:44 -0700921 sp<IBinder> getHandle();
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700922 const std::string& getName() const { return mName; }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700923 virtual void notifyAvailableFrames(nsecs_t /*expectedPresentTime*/) {}
Robert Carr105e64b2018-03-07 12:47:50 -0800924 virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; }
chaviw13fdc492017-06-27 12:40:18 -0700925 bool getPremultipledAlpha() const;
Igor Murashkina4a31492012-10-29 13:36:11 -0700926
Robert Carr2e102c92018-10-23 12:11:15 -0700927 bool mPendingHWCDestroy{false};
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800928 void setInputInfo(const InputWindowInfo& info);
Robert Carr720e5062018-07-30 17:45:14 -0700929
Arthur Hungd20b2702019-01-14 18:16:16 +0800930 InputWindowInfo fillInputInfo();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800931 bool hasInput() const;
Robert Carr2e102c92018-10-23 12:11:15 -0700932
David Sodman41fdfc92017-11-06 16:09:56 -0800933protected:
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700934 // -----------------------------------------------------------------------
Robert Carr1c5481e2019-07-01 14:42:27 -0700935 bool usingRelativeZ(LayerVector::StateSet stateSet) const;
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700936
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700937 bool mPremultipliedAlpha{true};
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700938 const std::string mName;
939 const std::string mTransactionName{"TX - " + mName};
Mathias Agopian13127d82013-03-05 17:47:11 -0800940
Chia-I Wuab0c3192017-08-01 11:29:00 -0700941 bool mPrimaryDisplayOnly = false;
942
Vishnu Nair8406fd72019-07-30 11:29:31 -0700943 // These are only accessed by the main thread or the tracing thread.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800944 State mDrawingState;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700945 // Store a copy of the pending state so that the drawing thread can access the
946 // states without a lock.
947 Vector<State> mPendingStatesSnapshot;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800948
Vishnu Nair8406fd72019-07-30 11:29:31 -0700949 // these are protected by an external lock (mStateLock)
950 State mCurrentState;
951 std::atomic<uint32_t> mTransactionFlags{0};
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800952 Vector<State> mPendingStates;
Dan Stoza7dde5992015-05-22 09:51:44 -0700953
Brian Andersond6927fb2016-07-23 23:37:30 -0700954 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800955 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700956
Brian Andersond6927fb2016-07-23 23:37:30 -0700957 // Timestamp history for the consumer to query.
958 // Accessed by both consumer and producer on main and binder threads.
959 Mutex mFrameEventHistoryMutex;
Brian Anderson3890c392016-07-25 12:48:08 -0700960 ConsumerFrameEventHistory mFrameEventHistory;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700961 FenceTimeline mAcquireTimeline;
962 FenceTimeline mReleaseTimeline;
Brian Andersond6927fb2016-07-23 23:37:30 -0700963
Mathias Agopiana67932f2011-04-20 14:20:59 -0700964 // main thread
Lloyd Pique0b785d82018-12-04 17:25:27 -0800965 sp<NativeHandle> mSidebandStream;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000966 // False if the buffer and its contents have been previously used for GPU
967 // composition, true otherwise.
968 bool mIsActiveBufferUpdatedForGpu = true;
969
Robert Carrc3574f72016-03-24 12:19:32 -0700970 // We encode unset as -1.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700971 int32_t mOverrideScalingMode{-1};
972 std::atomic<uint64_t> mCurrentFrameNumber{0};
Mathias Agopian13127d82013-03-05 17:47:11 -0800973 // Whether filtering is needed b/c of the drawingstate
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700974 bool mNeedsFiltering{false};
David Sodman0c69cad2017-08-21 12:12:51 -0700975
Robert Carr2e102c92018-10-23 12:11:15 -0700976 std::atomic<bool> mRemovedFromCurrentState{false};
chaviw8b3871a2017-11-01 17:41:01 -0700977
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700978 // page-flip thread (currently main thread)
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700979 bool mProtectedByApp{false}; // application requires protected path to external sink
Mathias Agopian13127d82013-03-05 17:47:11 -0800980
981 // protected by mLock
982 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -0700983
Mathias Agopian13127d82013-03-05 17:47:11 -0800984 const wp<Client> mClientRef;
Riley Andrews03414a12014-07-01 14:22:59 -0700985
986 // This layer can be a cursor on some displays.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700987 bool mPotentialCursor{false};
Dan Stoza6b9454d2014-11-07 16:00:59 -0800988
Robert Carr1f0a16a2016-10-24 16:27:39 -0700989 // Child list about to be committed/used for editing.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700990 LayerVector mCurrentChildren{LayerVector::StateSet::Current};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700991 // Child list used for rendering.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700992 LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700993
Chia-I Wue41dbe62017-06-13 14:10:56 -0700994 wp<Layer> mCurrentParent;
995 wp<Layer> mDrawingParent;
David Sodman9eeae692017-11-02 10:53:32 -0700996
chaviw5aedec92018-10-22 10:40:38 -0700997 // Can only be accessed with the SF state lock held.
998 bool mLayerDetached{false};
Robert Carr1323c952019-01-28 18:13:27 -0800999 // Can only be accessed with the SF state lock held.
1000 bool mChildrenChanged{false};
chaviw5aedec92018-10-22 10:40:38 -07001001
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001002 // Window types from WindowManager.LayoutParams
1003 const int mWindowType;
1004
chaviw4b129c22018-04-09 16:19:43 -07001005private:
1006 /**
1007 * Returns an unsorted vector of all layers that are part of this tree.
1008 * That includes the current layer and all its descendants.
1009 */
1010 std::vector<Layer*> getLayersInTree(LayerVector::StateSet stateSet);
1011 /**
1012 * Traverses layers that are part of this tree in the correct z order.
1013 * layersInTree must be sorted before calling this method.
1014 */
1015 void traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
1016 LayerVector::StateSet stateSet,
1017 const LayerVector::Visitor& visitor);
1018 LayerVector makeChildrenTraversalList(LayerVector::StateSet stateSet,
1019 const std::vector<Layer*>& layersInTree);
Vishnu Nair4351ad52019-02-11 14:13:02 -08001020
Ady Abraham60e42ea2020-03-09 19:17:31 -07001021 void updateTreeHasFrameRateVote();
1022
Vishnu Nair4351ad52019-02-11 14:13:02 -08001023 // Cached properties computed from drawing state
1024 // Effective transform taking into account parent transforms and any parent scaling.
1025 ui::Transform mEffectiveTransform;
1026
1027 // Bounds of the layer before any transformation is applied and before it has been cropped
1028 // by its parents.
1029 FloatRect mSourceBounds;
1030
1031 // Bounds of the layer in layer space. This is the mSourceBounds cropped by its layer crop and
1032 // its parent bounds.
1033 FloatRect mBounds;
1034
1035 // Layer bounds in screen space.
1036 FloatRect mScreenBounds;
chaviw606e5cf2019-03-01 10:12:10 -08001037
1038 void setZOrderRelativeOf(const wp<Layer>& relativeOf);
Robert Carrc0df3122019-04-11 13:18:21 -07001039
1040 bool mGetHandleCalled = false;
chaviw43cb3cb2019-05-31 15:23:41 -07001041
1042 void removeRemoteSyncPoints();
Vishnu Nair0f085c62019-08-30 08:49:12 -07001043
1044 // Tracks the process and user id of the caller when creating this layer
1045 // to help debugging.
1046 pid_t mCallingPid;
1047 uid_t mCallingUid;
chaviwb4c6e582019-08-16 14:35:07 -07001048
1049 // The current layer is a clone of mClonedFrom. This means that this layer will update it's
1050 // properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers,
1051 // this layer will update it's buffer. When mClonedFrom updates it's drawing state, children,
1052 // and relatives, this layer will update as well.
1053 wp<Layer> mClonedFrom;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001054
1055 // The inherited shadow radius after taking into account the layer hierarchy. This is the
1056 // final shadow radius for this layer. If a shadow is specified for a layer, then effective
1057 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius.
Vishnu Nairf37dcfb2019-11-16 07:37:09 -08001058 float mEffectiveShadowRadius = 0.f;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001059
1060 // Returns true if the layer can draw shadows on its border.
1061 virtual bool canDrawShadows() const { return true; }
chaviwaf87b3e2019-10-01 16:59:28 -07001062
1063 // Find the root of the cloned hierarchy, this means the first non cloned parent.
1064 // This will return null if first non cloned parent is not found.
1065 sp<Layer> getClonedRoot();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001066};
1067
Dominik Laskowski34157762018-10-31 13:07:19 -07001068} // namespace android
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001069
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001070#define RETURN_IF_NO_HWC_LAYER(displayDevice, ...) \
Dominik Laskowski34157762018-10-31 13:07:19 -07001071 do { \
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001072 if (!hasHwcLayer(displayDevice)) { \
Dominik Laskowski34157762018-10-31 13:07:19 -07001073 ALOGE("[%s] %s failed: no HWC layer found for display %s", mName.string(), \
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001074 __FUNCTION__, displayDevice->getDebugName().c_str()); \
Dominik Laskowski34157762018-10-31 13:07:19 -07001075 return __VA_ARGS__; \
1076 } \
1077 } while (false)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001078
1079#endif // ANDROID_LAYER_H