blob: 5d2144aed43a6b30a09bba5ae4bae770990f141e [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;
Mathias Agopian13127d82013-03-05 17:47:11 -0800262 };
263
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700264 explicit Layer(const LayerCreationArgs& args);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700265 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800266
Dominik Laskowski75848362019-11-11 17:57:20 -0800267 void onFirstRef() override;
268
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700269 int getWindowType() const { return mWindowType; }
270
Chia-I Wuab0c3192017-08-01 11:29:00 -0700271 void setPrimaryDisplayOnly() { mPrimaryDisplayOnly = true; }
Lloyd Piqueef36b002019-01-23 17:52:04 -0800272 bool getPrimaryDisplayOnly() const { return mPrimaryDisplayOnly; }
Chia-I Wuab0c3192017-08-01 11:29:00 -0700273
Robert Carr7bf247e2017-05-18 14:02:49 -0700274 // ------------------------------------------------------------------------
275 // Geometry setting functions.
276 //
277 // The following group of functions are used to specify the layers
278 // bounds, and the mapping of the texture on to those bounds. According
279 // to various settings changes to them may apply immediately, or be delayed until
280 // a pending resize is completed by the producer submitting a buffer. For example
281 // if we were to change the buffer size, and update the matrix ahead of the
282 // new buffer arriving, then we would be stretching the buffer to a different
283 // aspect before and after the buffer arriving, which probably isn't what we wanted.
284 //
285 // The first set of geometry functions are controlled by the scaling mode, described
286 // in window.h. The scaling mode may be set by the client, as it submits buffers.
287 // This value may be overriden through SurfaceControl, with setOverrideScalingMode.
288 //
289 // Put simply, if our scaling mode is SCALING_MODE_FREEZE, then
290 // matrix updates will not be applied while a resize is pending
291 // and the size and transform will remain in their previous state
292 // until a new buffer is submitted. If the scaling mode is another value
293 // then the old-buffer will immediately be scaled to the pending size
294 // and the new matrix will be immediately applied following this scaling
295 // transformation.
Robert Carr8d5227b2017-03-16 15:41:03 -0700296
Robert Carr7bf247e2017-05-18 14:02:49 -0700297 // Set the default buffer size for the assosciated Producer, in pixels. This is
298 // also the rendered size of the layer prior to any transformations. Parent
299 // or local matrix transformations will not affect the size of the buffer,
300 // but may affect it's on-screen size or clipping.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800301 virtual bool setSize(uint32_t w, uint32_t h);
Robert Carr7bf247e2017-05-18 14:02:49 -0700302 // Set a 2x2 transformation matrix on the layer. This transform
303 // will be applied after parent transforms, but before any final
304 // producer specified transform.
Marissa Wall61c58622018-07-18 10:12:20 -0700305 virtual bool setMatrix(const layer_state_t::matrix22_t& matrix,
306 bool allowNonRectPreservingTransforms);
Robert Carr7bf247e2017-05-18 14:02:49 -0700307
308 // This second set of geometry attributes are controlled by
309 // setGeometryAppliesWithResize, and their default mode is to be
310 // immediate. If setGeometryAppliesWithResize is specified
311 // while a resize is pending, then update of these attributes will
312 // be delayed until the resize completes.
313
314 // setPosition operates in parent buffer space (pre parent-transform) or display
315 // space for top-level layers.
chaviw214c89d2019-09-04 16:03:53 -0700316 virtual bool setPosition(float x, float y);
Robert Carr7bf247e2017-05-18 14:02:49 -0700317 // Buffer space
chaviw214c89d2019-09-04 16:03:53 -0700318 virtual bool setCrop_legacy(const Rect& crop);
Robert Carr8d5227b2017-03-16 15:41:03 -0700319
Robert Carr7bf247e2017-05-18 14:02:49 -0700320 // TODO(b/38182121): Could we eliminate the various latching modes by
321 // using the layer hierarchy?
322 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800323 virtual bool setLayer(int32_t z);
324 virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carrdb66e622017-04-10 16:55:57 -0700325
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800326 virtual bool setAlpha(float alpha);
Valerie Haudd0b7572019-01-29 14:59:27 -0800327 virtual bool setColor(const half3& /*color*/) { return false; };
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700328
329 // Set rounded corner radius for this layer and its children.
330 //
331 // We only support 1 radius per layer in the hierarchy, where parent layers have precedence.
332 // The shape of the rounded corner rectangle is specified by the crop rectangle of the layer
333 // from which we inferred the rounded corner radius.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800334 virtual bool setCornerRadius(float cornerRadius);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800335 // When non-zero, everything below this layer will be blurred by backgroundBlurRadius, which
336 // is specified in pixels.
337 virtual bool setBackgroundBlurRadius(int backgroundBlurRadius);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800338 virtual bool setTransparentRegionHint(const Region& transparent);
339 virtual bool setFlags(uint8_t flags, uint8_t mask);
340 virtual bool setLayerStack(uint32_t layerStack);
341 virtual uint32_t getLayerStack() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700342 virtual void deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle,
343 uint64_t frameNumber);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800344 virtual void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber);
345 virtual bool setOverrideScalingMode(int32_t overrideScalingMode);
Evan Roskyef876c92019-01-25 17:46:06 -0800346 virtual bool setMetadata(const LayerMetadata& data);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800347 virtual bool reparentChildren(const sp<IBinder>& layer);
Marissa Wall61c58622018-07-18 10:12:20 -0700348 virtual void setChildrenDrawingParent(const sp<Layer>& layer);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800349 virtual bool reparent(const sp<IBinder>& newParentHandle);
Marissa Wall61c58622018-07-18 10:12:20 -0700350 virtual bool detachChildren();
chaviw5aedec92018-10-22 10:40:38 -0700351 bool attachChildren();
352 bool isLayerDetached() const { return mLayerDetached; }
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800353 virtual bool setColorTransform(const mat4& matrix);
354 virtual mat4 getColorTransform() const;
355 virtual bool hasColorTransform() const;
Peiyong Linc502cb72019-03-01 15:00:23 -0800356 virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; }
Marissa Wall61c58622018-07-18 10:12:20 -0700357
358 // Used only to set BufferStateLayer state
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800359 virtual bool setTransform(uint32_t /*transform*/) { return false; };
360 virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };
361 virtual bool setCrop(const Rect& /*crop*/) { return false; };
362 virtual bool setFrame(const Rect& /*frame*/) { return false; };
Valerie Haubf784642020-01-29 07:25:23 -0800363 virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/, const sp<Fence>& /*acquireFence*/,
364 nsecs_t /*postTime*/, nsecs_t /*desiredPresentTime*/,
Marissa Wall947d34e2019-03-29 14:03:53 -0700365 const client_cache_t& /*clientCacheId*/) {
Ady Abraham09bd3922019-04-08 10:44:56 -0700366 return false;
Marissa Wall947d34e2019-03-29 14:03:53 -0700367 };
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800368 virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };
369 virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };
370 virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };
371 virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) { return false; };
372 virtual bool setApi(int32_t /*api*/) { return false; };
373 virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };
Marissa Walle2ffb422018-10-12 11:33:52 -0700374 virtual bool setTransactionCompletedListeners(
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800375 const std::vector<sp<CallbackHandle>>& /*handles*/) {
Marissa Walle2ffb422018-10-12 11:33:52 -0700376 return false;
377 };
Valerie Hau7618b232020-01-09 16:03:08 -0800378 virtual void forceSendCallbacks() {}
Valerie Hau871d6352020-01-29 08:44:02 -0800379 virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/,
380 nsecs_t /*requestedPresentTime*/) {
381 return false;
382 }
Valerie Haudd0b7572019-01-29 14:59:27 -0800383 virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace);
Peiyong Linc502cb72019-03-01 15:00:23 -0800384 virtual bool setColorSpaceAgnostic(const bool agnostic);
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700385 bool setShadowRadius(float shadowRadius);
Ana Krulecc84d09b2019-11-02 23:10:29 +0100386 virtual bool setFrameRateSelectionPriority(int32_t priority);
387 // If the variable is not set on the layer, it traverses up the tree to inherit the frame
388 // rate priority from its parent.
389 virtual int32_t getFrameRateSelectionPriority() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800390
chaviw4244e032019-09-04 11:27:49 -0700391 virtual ui::Dataspace getDataSpace() const { return ui::Dataspace::UNKNOWN; }
Chia-I Wu01591c92018-05-22 12:03:00 -0700392
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800393 // Before color management is introduced, contents on Android have to be
394 // desaturated in order to match what they appears like visually.
395 // With color management, these contents will appear desaturated, thus
396 // needed to be saturated so that they match what they are designed for
Chia-I Wu11481472018-05-04 10:43:19 -0700397 // visually.
398 bool isLegacyDataSpace() const;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800399
Lloyd Piquede196652020-01-22 17:29:58 -0800400 virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const;
401 virtual compositionengine::LayerFECompositionState* editCompositionState();
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800402
Dan Stozaee44edd2015-03-23 15:50:23 -0700403 // If we have received a new buffer this frame, we will pass its surface
404 // damage down to hardware composer. Otherwise, we must send a region with
405 // one empty rect.
Robert Carr105e64b2018-03-07 12:47:50 -0800406 virtual void useSurfaceDamage() {}
407 virtual void useEmptyDamage() {}
Dan Stozaee44edd2015-03-23 15:50:23 -0700408
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800409 uint32_t getTransactionFlags() const { return mTransactionFlags; }
410 uint32_t getTransactionFlags(uint32_t flags);
411 uint32_t setTransactionFlags(uint32_t flags);
Mathias Agopian13127d82013-03-05 17:47:11 -0800412
Lloyd Piqueef36b002019-01-23 17:52:04 -0800413 // Deprecated, please use compositionengine::Output::belongsInOutput()
414 // instead.
415 // TODO(lpique): Move the remaining callers (screencap) to the new function.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800416 bool belongsToDisplay(uint32_t layerStack, bool isPrimaryDisplay) const {
Chia-I Wuab0c3192017-08-01 11:29:00 -0700417 return getLayerStack() == layerStack && (!mPrimaryDisplayOnly || isPrimaryDisplay);
418 }
419
Vishnu Nair4351ad52019-02-11 14:13:02 -0800420 FloatRect getBounds(const Region& activeTransparentRegion) const;
421 FloatRect getBounds() const;
422
423 // Compute bounds for the layer and cache the results.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700424 void computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float shadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800425
Vishnu Nairc652ff82019-03-15 12:48:54 -0700426 // Returns the buffer scale transform if a scaling mode is set.
427 ui::Transform getBufferScaleTransform() const;
428
Vishnu Nair4351ad52019-02-11 14:13:02 -0800429 // Get effective layer transform, taking into account all its parent transform with any
430 // scaling if the parent scaling more is not NATIVE_WINDOW_SCALING_MODE_FREEZE.
Vishnu Nairc652ff82019-03-15 12:48:54 -0700431 ui::Transform getTransformWithScale(const ui::Transform& bufferScaleTransform) const;
432
433 // Returns the bounds of the layer without any buffer scaling.
434 FloatRect getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800435
Pablo Ceballos40845df2016-01-25 17:41:15 -0800436 int32_t getSequence() const { return sequence; }
437
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700438 // For tracing.
439 // TODO: Replace with raw buffer id from buffer metadata when that becomes available.
440 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces
441 // creates its tracks by buffer id and has no way of associating a buffer back to the process
442 // that created it, the current implementation is only sufficient for cases where a buffer is
443 // only used within a single layer.
chaviwd62d3062019-09-04 14:48:02 -0700444 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; }
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700445
Mathias Agopian13127d82013-03-05 17:47:11 -0800446 // -----------------------------------------------------------------------
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700447 // Virtuals
chaviw8a01fa42019-08-19 12:39:31 -0700448
449 // Provide unique string for each class type in the Layer hierarchy
450 virtual const char* getType() const = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -0800451
Mathias Agopian13127d82013-03-05 17:47:11 -0800452 /*
453 * isOpaque - true if this surface is opaque
Andy McFadden4125a4f2014-01-29 17:17:11 -0800454 *
455 * This takes into account the buffer format (i.e. whether or not the
456 * pixel format includes an alpha channel) and the "opaque" flag set
457 * on the layer. It does not examine the current plane alpha value.
Mathias Agopian13127d82013-03-05 17:47:11 -0800458 */
Robert Carr105e64b2018-03-07 12:47:50 -0800459 virtual bool isOpaque(const Layer::State&) const { return false; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800460
461 /*
462 * isSecure - true if this surface is secure, that is if it prevents
463 * screenshots or VNC servers.
464 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800465 bool isSecure() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800466
467 /*
468 * isVisible - true if this layer is visible, false otherwise
469 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800470 virtual bool isVisible() const = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800471
Mathias Agopian13127d82013-03-05 17:47:11 -0800472 /*
Robert Carr1f0a16a2016-10-24 16:27:39 -0700473 * isHiddenByPolicy - true if this layer has been forced invisible.
474 * just because this is false, doesn't mean isVisible() is true.
475 * For example if this layer has no active buffer, it may not be hidden by
476 * policy, but it still can not be visible.
477 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800478 bool isHiddenByPolicy() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700479
480 /*
chaviw3e727cd2019-01-31 13:41:05 -0800481 * Returns whether this layer can receive input.
482 */
483 virtual bool canReceiveInput() const;
484
485 /*
Peiyong Linfb530cf2018-12-15 05:07:38 +0000486 * isProtected - true if the layer may contain protected content in the
487 * GRALLOC_USAGE_PROTECTED sense.
488 */
489 virtual bool isProtected() const { return false; }
490
491 /*
Mathias Agopian13127d82013-03-05 17:47:11 -0800492 * isFixedSize - true if content has a fixed size
493 */
Robert Carr105e64b2018-03-07 12:47:50 -0800494 virtual bool isFixedSize() const { return true; }
495
Lloyd Piquea83776c2019-01-29 18:42:32 -0800496 /*
497 * usesSourceCrop - true if content should use a source crop
498 */
499 virtual bool usesSourceCrop() const { return false; }
500
Dan Stoza436ccf32018-06-21 12:10:12 -0700501 // Most layers aren't created from the main thread, and therefore need to
502 // grab the SF state lock to access HWC, but ContainerLayer does, so we need
503 // to avoid grabbing the lock again to avoid deadlock
504 virtual bool isCreatedFromMainThread() const { return false; }
505
Robert Carr2e102c92018-10-23 12:11:15 -0700506 bool isRemovedFromCurrentState() const;
chaviw8b3871a2017-11-01 17:41:01 -0700507
chaviw6d89e2d2020-01-14 14:42:01 -0800508 LayerProto* writeToProto(LayersProto& layersProto,
509 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
chaviw08f3cb22020-01-13 13:17:21 -0800510
Vishnu Nair8406fd72019-07-30 11:29:31 -0700511 // Write states that are modified by the main thread. This includes drawing
512 // state as well as buffer data. This should be called in the main or tracing
513 // thread.
514 void writeToProtoDrawingState(LayerProto* layerInfo,
515 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700516 // Write drawing or current state. If writing current state, the caller should hold the
517 // external mStateLock. If writing drawing state, this function should be called on the
518 // main or tracing thread.
519 void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet stateSet,
520 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800521
Marissa Wall61c58622018-07-18 10:12:20 -0700522 virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }
523 virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }
524 virtual uint32_t getActiveHeight(const Layer::State& s) const { return s.active_legacy.h; }
Peiyong Linefefaac2018-08-17 12:27:51 -0700525 virtual ui::Transform getActiveTransform(const Layer::State& s) const {
Marissa Wall61c58622018-07-18 10:12:20 -0700526 return s.active_legacy.transform;
527 }
528 virtual Region getActiveTransparentRegion(const Layer::State& s) const {
529 return s.activeTransparentRegion_legacy;
530 }
531 virtual Rect getCrop(const Layer::State& s) const { return s.crop_legacy; }
Lloyd Piquef16688f2019-02-19 17:47:57 -0800532 virtual bool needsFiltering(const sp<const DisplayDevice>&) const { return false; }
Peiyong Lin97067b02019-03-29 17:34:45 +0000533
chaviw74b03172019-08-19 11:09:03 -0700534 // This layer is not a clone, but it's the parent to the cloned hierarchy. The
535 // variable mClonedChild represents the top layer that will be cloned so this
536 // layer will be the parent of mClonedChild.
537 // The layers in the cloned hierarchy will match the lifetime of the real layers. That is
538 // if the real layer is destroyed, then the clone layer will also be destroyed.
539 sp<Layer> mClonedChild;
chaviwb4c6e582019-08-16 14:35:07 -0700540
chaviw74b03172019-08-19 11:09:03 -0700541 virtual sp<Layer> createClone() = 0;
542 void updateMirrorInfo();
543 virtual void updateCloneBufferInfo(){};
544
545protected:
Lloyd Piquede196652020-01-22 17:29:58 -0800546 sp<compositionengine::LayerFE> asLayerFE() const;
chaviw74b03172019-08-19 11:09:03 -0700547 sp<Layer> getClonedFrom() { return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr; }
548 bool isClone() { return mClonedFrom != nullptr; }
549 bool isClonedFromAlive() { return getClonedFrom() != nullptr; }
550
chaviwb4c6e582019-08-16 14:35:07 -0700551 virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
552
chaviw74b03172019-08-19 11:09:03 -0700553 void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
554 void updateClonedChildren(const sp<Layer>& mirrorRoot,
555 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
chaviwaf87b3e2019-10-01 16:59:28 -0700556 void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
chaviw74b03172019-08-19 11:09:03 -0700557 void addChildToDrawing(const sp<Layer>& layer);
chaviwaf87b3e2019-10-01 16:59:28 -0700558 void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800559 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
560 compositionengine::LayerFE::ClientCompositionTargetSettings&);
561 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareShadowClientComposition(
562 const LayerFE::LayerSettings& layerSettings, const Rect& displayViewport,
563 ui::Dataspace outputDataspace);
564 // Modifies the passed in layer settings to clear the contents. If the blackout flag is set,
565 // the settings clears the content with a solid black fill.
566 void prepareClearClientComposition(LayerFE::LayerSettings& layerSettings, bool blackout) const;
chaviw74b03172019-08-19 11:09:03 -0700567
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700568public:
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800569 /*
570 * compositionengine::LayerFE overrides
571 */
Lloyd Piquede196652020-01-22 17:29:58 -0800572 const compositionengine::LayerFECompositionState* getCompositionState() const override;
Lloyd Piquef16688f2019-02-19 17:47:57 -0800573 bool onPreComposition(nsecs_t) override;
Lloyd Piquede196652020-01-22 17:29:58 -0800574 void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800575 std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList(
Lloyd Piquef16688f2019-02-19 17:47:57 -0800576 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800577 void onLayerDisplayed(const sp<Fence>& releaseFence) override;
Lloyd Piquea83776c2019-01-29 18:42:32 -0800578 const char* getDebugName() const override;
Lloyd Piquecb54b3b2019-01-29 18:42:54 -0800579
Lloyd Piquea83776c2019-01-29 18:42:32 -0800580protected:
Lloyd Piquede196652020-01-22 17:29:58 -0800581 void prepareBasicGeometryCompositionState();
582 void prepareGeometryCompositionState();
583 virtual void preparePerFrameCompositionState();
584 void prepareCursorCompositionState();
Lloyd Piquea83776c2019-01-29 18:42:32 -0800585
586public:
Robert Carr105e64b2018-03-07 12:47:50 -0800587 virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {}
David Sodmaneb085e02017-10-05 18:49:04 -0700588
Chia-I Wu692e0832018-06-05 15:46:58 -0700589 virtual bool isHdrY410() const { return false; }
590
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800591 Hwc2::IComposerClient::Composition getCompositionType(
592 const sp<const DisplayDevice>& display) const;
593 bool getClearClientTarget(const sp<const DisplayDevice>& display) const;
Riley Andrews03414a12014-07-01 14:22:59 -0700594
Ana Krulec010d2192018-10-08 06:29:54 -0700595 virtual bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const { return false; }
Robert Carr105e64b2018-03-07 12:47:50 -0800596 virtual void setTransformHint(uint32_t /*orientation*/) const { }
Dan Stoza6b9454d2014-11-07 16:00:59 -0800597
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700598 /*
Dan Stozae77c7662016-05-13 11:37:28 -0700599 * called after composition.
600 * returns true if the layer latched a new buffer this frame.
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700601 */
Adithya Srinivasanb69e0762019-11-11 18:39:53 -0800602 virtual bool onPostComposition(sp<const DisplayDevice> /*displayDevice*/,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700603 const std::shared_ptr<FenceTime>& /*glDoneFence*/,
Robert Carr105e64b2018-03-07 12:47:50 -0800604 const std::shared_ptr<FenceTime>& /*presentFence*/,
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800605 const CompositorTiming& /*compositorTiming*/) {
Robert Carr105e64b2018-03-07 12:47:50 -0800606 return false;
607 }
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700608
Dan Stoza9e56aa02015-11-02 13:00:03 -0800609 // If a buffer was replaced this frame, release the former buffer
Robert Carr105e64b2018-03-07 12:47:50 -0800610 virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { }
611
Valerie Hau871d6352020-01-29 08:44:02 -0800612 virtual void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& /*glDoneFence*/,
613 const CompositorTiming& /*compositorTiming*/) {}
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700614 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700615 * doTransaction - process the transaction. This is a good place to figure
616 * out which attributes of the surface have changed.
617 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800618 uint32_t doTransaction(uint32_t transactionFlags);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700619
620 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700621 * latchBuffer - called each time the screen is redrawn and returns whether
622 * the visible regions need to be recomputed (this is a fairly heavy
623 * operation, so this should be set only if needed). Typically this is used
624 * to figure out if the content or size of a surface has changed.
625 */
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700626 virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
627 nsecs_t /*expectedPresentTime*/) {
628 return false;
Robert Carr105e64b2018-03-07 12:47:50 -0800629 }
630
631 virtual bool isBufferLatched() const { return false; }
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700632
chaviw49a108c2019-08-12 11:23:06 -0700633 virtual void latchAndReleaseBuffer() {}
634
Mathias Agopian13127d82013-03-05 17:47:11 -0800635 /*
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700636 * Remove relative z for the layer if its relative parent is not part of the
637 * provided layer tree.
638 */
639 void removeRelativeZ(const std::vector<Layer*>& layersInTree);
640
641 /*
642 * Remove from current state and mark for removal.
643 */
644 void removeFromCurrentState();
645
646 /*
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800647 * called with the state lock from a binder thread when the layer is
Chia-I Wuc6657022017-08-15 11:18:17 -0700648 * removed from the current list to the pending removal list
649 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800650 void onRemovedFromCurrentState();
Chia-I Wuc6657022017-08-15 11:18:17 -0700651
chaviw61626f22018-11-15 16:26:27 -0800652 /*
653 * Called when the layer is added back to the current state list.
654 */
655 void addToCurrentState();
656
Andy McFaddenbf974ab2012-12-04 16:51:15 -0800657 // Updates the transform hint in our SurfaceFlingerConsumer to match
Mathias Agopian84300952012-11-21 16:02:13 -0800658 // the current orientation of the display device.
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700659 void updateTransformHint(const sp<const DisplayDevice>& display) const;
Andy McFadden69052052012-09-14 16:10:11 -0700660
Mathias Agopian13127d82013-03-05 17:47:11 -0800661 /*
662 * returns the rectangle that crops the content of the layer and scales it
663 * to the layer's size.
664 */
chaviw4244e032019-09-04 11:27:49 -0700665 virtual Rect getBufferCrop() const { return Rect(); }
666
667 /*
668 * Returns the transform applied to the buffer.
669 */
670 virtual uint32_t getBufferTransform() const { return 0; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800671
chaviwd62d3062019-09-04 14:48:02 -0700672 virtual sp<GraphicBuffer> getBuffer() const { return nullptr; }
673
Eric Penner51c59cd2014-07-28 19:51:58 -0700674 /*
Marissa Wallfd668622018-05-10 10:21:13 -0700675 * Returns if a frame is ready
Eric Penner51c59cd2014-07-28 19:51:58 -0700676 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800677 virtual bool hasReadyFrame() const { return false; }
Eric Penner51c59cd2014-07-28 19:51:58 -0700678
Marissa Wallfd668622018-05-10 10:21:13 -0700679 virtual int32_t getQueuedFrameCount() const { return 0; }
Kalle Raitaa099a242017-01-11 11:17:29 -0800680
Dan Stoza9e56aa02015-11-02 13:00:03 -0800681 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800682 inline const State& getDrawingState() const { return mDrawingState; }
683 inline const State& getCurrentState() const { return mCurrentState; }
684 inline State& getCurrentState() { return mCurrentState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800685
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800686 LayerDebugInfo getLayerDebugInfo() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800687
688 /* always call base class first */
Yiwei Zhang5434a782018-12-05 18:06:32 -0800689 static void miniDumpHeader(std::string& result);
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800690 void miniDump(std::string& result, const sp<DisplayDevice>& display) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800691 void dumpFrameStats(std::string& result) const;
692 void dumpFrameEvents(std::string& result);
Vishnu Nair0f085c62019-08-30 08:49:12 -0700693 void dumpCallingUidPid(std::string& result) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700694 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700695 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700696 void getFrameStats(FrameStats* outStats) const;
Mathias Agopian1b5e1022010-04-20 17:55:49 -0700697
Robert Carr105e64b2018-03-07 12:47:50 -0800698 virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) {
699 return {};
700 }
Dan Stozae77c7662016-05-13 11:37:28 -0700701
Brian Anderson5ea5e592016-12-01 16:54:33 -0800702 void onDisconnect();
Brian Anderson3890c392016-07-25 12:48:08 -0700703 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
David Sodman41fdfc92017-11-06 16:09:56 -0800704 FrameEventHistoryDelta* outDelta);
Pablo Ceballosce796e72016-02-04 19:10:51 -0800705
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800706 virtual bool getTransformToDisplayInverse() const { return false; }
Robert Carr367c5682016-06-20 11:55:28 -0700707
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800708 ui::Transform getTransform() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700709
Robert Carr6452f122017-03-21 10:41:29 -0700710 // Returns the Alpha of the Surface, accounting for the Alpha
711 // of parent Surfaces in the hierarchy (alpha's will be multiplied
712 // down the hierarchy).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800713 half getAlpha() const;
714 half4 getColor() const;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800715 int32_t getBackgroundBlurRadius() const;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800716 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; };
Robert Carr6452f122017-03-21 10:41:29 -0700717
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700718 // Returns how rounded corners should be drawn for this layer.
719 // This will traverse the hierarchy until it reaches its root, finding topmost rounded
720 // corner definition and converting it into current layer's coordinates.
721 // As of now, only 1 corner radius per display list is supported. Subsequent ones will be
722 // ignored.
Valerie Hau92bf5482020-02-10 09:49:08 -0800723 virtual RoundedCornerState getRoundedCornerState() const;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700724
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800725 renderengine::ShadowSettings getShadowSettings(const Rect& viewport) const;
726
Edgar Arriaga844fa672020-01-16 14:21:42 -0800727 /**
728 * Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder
729 * which will not emit children who have relativeZOrder to another layer, this method
730 * just directly emits all children. It also emits them in no particular order.
731 * So this method is not suitable for graphical operations, as it doesn't represent
732 * the scene state, but it's also more efficient than traverseInZOrder and so useful for
733 * book-keeping.
734 */
735 void traverse(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor);
Dan Stoza412903f2017-04-27 13:42:17 -0700736 void traverseInReverseZOrder(LayerVector::StateSet stateSet,
737 const LayerVector::Visitor& visitor);
738 void traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700739
chaviw4b129c22018-04-09 16:19:43 -0700740 /**
741 * Traverse only children in z order, ignoring relative layers that are not children of the
742 * parent.
743 */
chaviwa76b2712017-09-20 12:02:26 -0700744 void traverseChildrenInZOrder(LayerVector::StateSet stateSet,
745 const LayerVector::Visitor& visitor);
746
Chia-I Wu98f1c102017-05-30 14:54:08 -0700747 size_t getChildrenCount() const;
Valerie Hauc5686802019-11-22 14:18:09 -0800748
749 // ONLY CALL THIS FROM THE LAYER DTOR!
750 // See b/141111965. We need to add current children to offscreen layers in
751 // the layer dtor so as not to dangle layers. Since the layer has not
752 // committed its transaction when the layer is destroyed, we must add
753 // current children. This is safe in the dtor as we will no longer update
754 // the current state, but should not be called anywhere else!
755 LayerVector& getCurrentChildren() { return mCurrentChildren; }
756
Robert Carr1f0a16a2016-10-24 16:27:39 -0700757 void addChild(const sp<Layer>& layer);
758 // Returns index if removed, or negative value otherwise
759 // for symmetry with Vector::remove
760 ssize_t removeChild(const sp<Layer>& layer);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700761 sp<Layer> getParent() const { return mCurrentParent.promote(); }
Robert Carr1f0a16a2016-10-24 16:27:39 -0700762 bool hasParent() const { return getParent() != nullptr; }
Vishnu Nair4351ad52019-02-11 14:13:02 -0800763 Rect getScreenBounds(bool reduceTransparentRegion = true) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700764 bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
Robert Carr503c7042017-09-27 15:06:08 -0700765 bool setChildRelativeLayer(const sp<Layer>& childLayer,
766 const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700767
768 // Copy the current list of children to the drawing state. Called by
769 // SurfaceFlinger to complete a transaction.
770 void commitChildList();
chaviw301b1d82019-11-06 13:15:09 -0800771 int32_t getZ(LayerVector::StateSet stateSet) const;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800772 virtual void pushPendingState();
David Sodman41fdfc92017-11-06 16:09:56 -0800773
Vishnu Nair88a11f22018-11-28 18:30:57 -0800774 /**
775 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing
776 * any buffer transformations. If the layer has no buffer then return INVALID_RECT.
777 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800778 virtual Rect getBufferSize(const Layer::State&) const { return Rect::INVALID_RECT; }
Vishnu Nair88a11f22018-11-28 18:30:57 -0800779
Vishnu Nair4351ad52019-02-11 14:13:02 -0800780 /**
781 * Returns the source bounds. If the bounds are not defined, it is inferred from the
782 * buffer size. Failing that, the bounds are determined from the passed in parent bounds.
783 * For the root layer, this is the display viewport size.
784 */
785 virtual FloatRect computeSourceBounds(const FloatRect& parentBounds) const {
786 return parentBounds;
787 }
788
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800789 compositionengine::OutputLayer* findOutputLayerForDisplay(
790 const sp<const DisplayDevice>& display) const;
791
Lloyd Piquea2468662019-03-07 21:31:06 -0800792 Region debugGetVisibleRegionOnDefaultDisplay() const;
793
Vishnu Nairefc42e22019-12-03 17:36:12 -0800794 /**
795 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
796 * INVALID_RECT if the layer has no buffer and no crop.
797 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer
798 * bounds are constrained by its parent bounds.
799 */
800 Rect getCroppedBufferSize(const Layer::State& s) const;
801
Steven Thomas62a4cf82020-01-31 12:04:03 -0800802 bool setFrameRate(FrameRate frameRate);
Ady Abraham71c437d2020-01-31 15:56:57 -0800803 virtual FrameRate getFrameRate() const;
Steven Thomas3172e202020-01-06 19:25:30 -0800804
Mathias Agopian13127d82013-03-05 17:47:11 -0800805protected:
806 // constant
807 sp<SurfaceFlinger> mFlinger;
Mathias Agopian13127d82013-03-05 17:47:11 -0800808 /*
809 * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
810 * is called.
811 */
812 class LayerCleaner {
813 sp<SurfaceFlinger> mFlinger;
Robert Carr2e102c92018-10-23 12:11:15 -0700814 sp<Layer> mLayer;
David Sodman41fdfc92017-11-06 16:09:56 -0800815
Mathias Agopian13127d82013-03-05 17:47:11 -0800816 protected:
Irvel468051e2016-06-13 16:44:44 -0700817 ~LayerCleaner() {
818 // destroy client resources
Robert Carr2e102c92018-10-23 12:11:15 -0700819 mFlinger->onHandleDestroyed(mLayer);
Irvel468051e2016-06-13 16:44:44 -0700820 }
David Sodman41fdfc92017-11-06 16:09:56 -0800821
Mathias Agopian13127d82013-03-05 17:47:11 -0800822 public:
David Sodman41fdfc92017-11-06 16:09:56 -0800823 LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
824 : mFlinger(flinger), mLayer(layer) {}
Mathias Agopian13127d82013-03-05 17:47:11 -0800825 };
826
Lloyd Pique4dccc412018-01-22 17:21:36 -0800827 friend class impl::SurfaceInterceptor;
David Sodmaneb085e02017-10-05 18:49:04 -0700828
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700829 // For unit tests
830 friend class TestableSurfaceFlinger;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100831 friend class RefreshRateSelectionTest;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700832
Valerie Haub153bab2019-03-05 10:47:28 -0800833 virtual void commitTransaction(const State& stateToCommit);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700834
Mathias Agopian3330b202009-10-05 17:07:12 -0700835 uint32_t getEffectiveUsage(uint32_t usage) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700836
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700837 /**
838 * Setup rounded corners coordinates of this layer, taking into account the layer bounds and
839 * crop coordinates, transforming them into layer space.
840 */
841 void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700842 void setParent(const sp<Layer>& layer);
Robert Carr29abff82017-12-04 13:51:20 -0800843 LayerVector makeTraversalList(LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800844 void addZOrderRelative(const wp<Layer>& relative);
845 void removeZOrderRelative(const wp<Layer>& relative);
Robert Carrdb66e622017-04-10 16:55:57 -0700846
David Sodman41fdfc92017-11-06 16:09:56 -0800847 class SyncPoint {
Dan Stoza7dde5992015-05-22 09:51:44 -0700848 public:
chaviw43cb3cb2019-05-31 15:23:41 -0700849 explicit SyncPoint(uint64_t frameNumber, wp<Layer> requestedSyncLayer)
850 : mFrameNumber(frameNumber),
851 mFrameIsAvailable(false),
852 mTransactionIsApplied(false),
853 mRequestedSyncLayer(requestedSyncLayer) {}
Dan Stoza7dde5992015-05-22 09:51:44 -0700854
David Sodman41fdfc92017-11-06 16:09:56 -0800855 uint64_t getFrameNumber() const { return mFrameNumber; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700856
David Sodman41fdfc92017-11-06 16:09:56 -0800857 bool frameIsAvailable() const { return mFrameIsAvailable; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700858
David Sodman41fdfc92017-11-06 16:09:56 -0800859 void setFrameAvailable() { mFrameIsAvailable = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700860
David Sodman41fdfc92017-11-06 16:09:56 -0800861 bool transactionIsApplied() const { return mTransactionIsApplied; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700862
David Sodman41fdfc92017-11-06 16:09:56 -0800863 void setTransactionApplied() { mTransactionIsApplied = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700864
chaviw43cb3cb2019-05-31 15:23:41 -0700865 sp<Layer> getRequestedSyncLayer() { return mRequestedSyncLayer.promote(); }
866
Dan Stoza7dde5992015-05-22 09:51:44 -0700867 private:
868 const uint64_t mFrameNumber;
869 std::atomic<bool> mFrameIsAvailable;
870 std::atomic<bool> mTransactionIsApplied;
chaviw43cb3cb2019-05-31 15:23:41 -0700871 wp<Layer> mRequestedSyncLayer;
Dan Stoza7dde5992015-05-22 09:51:44 -0700872 };
873
Dan Stozacac35382016-01-27 12:21:06 -0800874 // SyncPoints which will be signaled when the correct frame is at the head
875 // of the queue and dropped after the frame has been latched. Protected by
876 // mLocalSyncPointMutex.
877 Mutex mLocalSyncPointMutex;
Dan Stoza7dde5992015-05-22 09:51:44 -0700878 std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
879
Dan Stozacac35382016-01-27 12:21:06 -0800880 // SyncPoints which will be signaled and then dropped when the transaction
881 // is applied
Dan Stoza7dde5992015-05-22 09:51:44 -0700882 std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
883
Dan Stozacac35382016-01-27 12:21:06 -0800884 // Returns false if the relevant frame has already been latched
885 bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
Dan Stoza7dde5992015-05-22 09:51:44 -0700886
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800887 void popPendingState(State* stateToCommit);
888 virtual bool applyPendingStates(State* stateToCommit);
889 virtual uint32_t doTransactionResize(uint32_t flags, Layer::State* stateToCommit);
Robert Carrc3574f72016-03-24 12:19:32 -0700890
891 // Returns mCurrentScaling mode (originating from the
892 // Client) or mOverrideScalingMode mode (originating from
893 // the Surface Controller) if set.
Robert Carr105e64b2018-03-07 12:47:50 -0800894 virtual uint32_t getEffectiveScalingMode() const { return 0; }
David Sodman41fdfc92017-11-06 16:09:56 -0800895
Dan Stoza7dde5992015-05-22 09:51:44 -0700896public:
Irvel468051e2016-06-13 16:44:44 -0700897 /*
898 * The layer handle is just a BBinder object passed to the client
899 * (remote process) -- we don't keep any reference on our side such that
900 * the dtor is called when the remote side let go of its reference.
901 *
902 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
903 * this layer when the handle is destroyed.
904 */
905 class Handle : public BBinder, public LayerCleaner {
David Sodman41fdfc92017-11-06 16:09:56 -0800906 public:
907 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
908 : LayerCleaner(flinger, layer), owner(layer) {}
Irvel468051e2016-06-13 16:44:44 -0700909
David Sodman41fdfc92017-11-06 16:09:56 -0800910 wp<Layer> owner;
Irvel468051e2016-06-13 16:44:44 -0700911 };
912
Robert Carrc0df3122019-04-11 13:18:21 -0700913 // Creates a new handle each time, so we only expect
914 // this to be called once.
Irvel468051e2016-06-13 16:44:44 -0700915 sp<IBinder> getHandle();
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700916 const std::string& getName() const { return mName; }
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700917 virtual void notifyAvailableFrames(nsecs_t /*expectedPresentTime*/) {}
Robert Carr105e64b2018-03-07 12:47:50 -0800918 virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; }
chaviw13fdc492017-06-27 12:40:18 -0700919 bool getPremultipledAlpha() const;
Igor Murashkina4a31492012-10-29 13:36:11 -0700920
Robert Carr2e102c92018-10-23 12:11:15 -0700921 bool mPendingHWCDestroy{false};
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800922 void setInputInfo(const InputWindowInfo& info);
Robert Carr720e5062018-07-30 17:45:14 -0700923
Arthur Hungd20b2702019-01-14 18:16:16 +0800924 InputWindowInfo fillInputInfo();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800925 bool hasInput() const;
Robert Carr2e102c92018-10-23 12:11:15 -0700926
David Sodman41fdfc92017-11-06 16:09:56 -0800927protected:
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700928 // -----------------------------------------------------------------------
Robert Carr1c5481e2019-07-01 14:42:27 -0700929 bool usingRelativeZ(LayerVector::StateSet stateSet) const;
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700930
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700931 bool mPremultipliedAlpha{true};
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700932 const std::string mName;
933 const std::string mTransactionName{"TX - " + mName};
Mathias Agopian13127d82013-03-05 17:47:11 -0800934
Chia-I Wuab0c3192017-08-01 11:29:00 -0700935 bool mPrimaryDisplayOnly = false;
936
Vishnu Nair8406fd72019-07-30 11:29:31 -0700937 // These are only accessed by the main thread or the tracing thread.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800938 State mDrawingState;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700939 // Store a copy of the pending state so that the drawing thread can access the
940 // states without a lock.
941 Vector<State> mPendingStatesSnapshot;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800942
Vishnu Nair8406fd72019-07-30 11:29:31 -0700943 // these are protected by an external lock (mStateLock)
944 State mCurrentState;
945 std::atomic<uint32_t> mTransactionFlags{0};
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800946 Vector<State> mPendingStates;
Dan Stoza7dde5992015-05-22 09:51:44 -0700947
Brian Andersond6927fb2016-07-23 23:37:30 -0700948 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800949 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700950
Brian Andersond6927fb2016-07-23 23:37:30 -0700951 // Timestamp history for the consumer to query.
952 // Accessed by both consumer and producer on main and binder threads.
953 Mutex mFrameEventHistoryMutex;
Brian Anderson3890c392016-07-25 12:48:08 -0700954 ConsumerFrameEventHistory mFrameEventHistory;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700955 FenceTimeline mAcquireTimeline;
956 FenceTimeline mReleaseTimeline;
Brian Andersond6927fb2016-07-23 23:37:30 -0700957
Mathias Agopiana67932f2011-04-20 14:20:59 -0700958 // main thread
Lloyd Pique0b785d82018-12-04 17:25:27 -0800959 sp<NativeHandle> mSidebandStream;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000960 // False if the buffer and its contents have been previously used for GPU
961 // composition, true otherwise.
962 bool mIsActiveBufferUpdatedForGpu = true;
963
Robert Carrc3574f72016-03-24 12:19:32 -0700964 // We encode unset as -1.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700965 int32_t mOverrideScalingMode{-1};
966 std::atomic<uint64_t> mCurrentFrameNumber{0};
Mathias Agopian13127d82013-03-05 17:47:11 -0800967 // Whether filtering is needed b/c of the drawingstate
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700968 bool mNeedsFiltering{false};
David Sodman0c69cad2017-08-21 12:12:51 -0700969
Robert Carr2e102c92018-10-23 12:11:15 -0700970 std::atomic<bool> mRemovedFromCurrentState{false};
chaviw8b3871a2017-11-01 17:41:01 -0700971
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700972 // page-flip thread (currently main thread)
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700973 bool mProtectedByApp{false}; // application requires protected path to external sink
Mathias Agopian13127d82013-03-05 17:47:11 -0800974
975 // protected by mLock
976 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -0700977
Mathias Agopian13127d82013-03-05 17:47:11 -0800978 const wp<Client> mClientRef;
Riley Andrews03414a12014-07-01 14:22:59 -0700979
980 // This layer can be a cursor on some displays.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700981 bool mPotentialCursor{false};
Dan Stoza6b9454d2014-11-07 16:00:59 -0800982
Robert Carr1f0a16a2016-10-24 16:27:39 -0700983 // Child list about to be committed/used for editing.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700984 LayerVector mCurrentChildren{LayerVector::StateSet::Current};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700985 // Child list used for rendering.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700986 LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700987
Chia-I Wue41dbe62017-06-13 14:10:56 -0700988 wp<Layer> mCurrentParent;
989 wp<Layer> mDrawingParent;
David Sodman9eeae692017-11-02 10:53:32 -0700990
chaviw5aedec92018-10-22 10:40:38 -0700991 // Can only be accessed with the SF state lock held.
992 bool mLayerDetached{false};
Robert Carr1323c952019-01-28 18:13:27 -0800993 // Can only be accessed with the SF state lock held.
994 bool mChildrenChanged{false};
chaviw5aedec92018-10-22 10:40:38 -0700995
Ady Abraham8f1ee7f2019-04-05 10:32:50 -0700996 // Window types from WindowManager.LayoutParams
997 const int mWindowType;
998
chaviw4b129c22018-04-09 16:19:43 -0700999private:
1000 /**
1001 * Returns an unsorted vector of all layers that are part of this tree.
1002 * That includes the current layer and all its descendants.
1003 */
1004 std::vector<Layer*> getLayersInTree(LayerVector::StateSet stateSet);
1005 /**
1006 * Traverses layers that are part of this tree in the correct z order.
1007 * layersInTree must be sorted before calling this method.
1008 */
1009 void traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
1010 LayerVector::StateSet stateSet,
1011 const LayerVector::Visitor& visitor);
1012 LayerVector makeChildrenTraversalList(LayerVector::StateSet stateSet,
1013 const std::vector<Layer*>& layersInTree);
Vishnu Nair4351ad52019-02-11 14:13:02 -08001014
1015 // Cached properties computed from drawing state
1016 // Effective transform taking into account parent transforms and any parent scaling.
1017 ui::Transform mEffectiveTransform;
1018
1019 // Bounds of the layer before any transformation is applied and before it has been cropped
1020 // by its parents.
1021 FloatRect mSourceBounds;
1022
1023 // Bounds of the layer in layer space. This is the mSourceBounds cropped by its layer crop and
1024 // its parent bounds.
1025 FloatRect mBounds;
1026
1027 // Layer bounds in screen space.
1028 FloatRect mScreenBounds;
chaviw606e5cf2019-03-01 10:12:10 -08001029
1030 void setZOrderRelativeOf(const wp<Layer>& relativeOf);
Robert Carrc0df3122019-04-11 13:18:21 -07001031
1032 bool mGetHandleCalled = false;
chaviw43cb3cb2019-05-31 15:23:41 -07001033
1034 void removeRemoteSyncPoints();
Vishnu Nair0f085c62019-08-30 08:49:12 -07001035
1036 // Tracks the process and user id of the caller when creating this layer
1037 // to help debugging.
1038 pid_t mCallingPid;
1039 uid_t mCallingUid;
chaviwb4c6e582019-08-16 14:35:07 -07001040
1041 // The current layer is a clone of mClonedFrom. This means that this layer will update it's
1042 // properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers,
1043 // this layer will update it's buffer. When mClonedFrom updates it's drawing state, children,
1044 // and relatives, this layer will update as well.
1045 wp<Layer> mClonedFrom;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001046
1047 // The inherited shadow radius after taking into account the layer hierarchy. This is the
1048 // final shadow radius for this layer. If a shadow is specified for a layer, then effective
1049 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius.
Vishnu Nairf37dcfb2019-11-16 07:37:09 -08001050 float mEffectiveShadowRadius = 0.f;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001051
1052 // Returns true if the layer can draw shadows on its border.
1053 virtual bool canDrawShadows() const { return true; }
chaviwaf87b3e2019-10-01 16:59:28 -07001054
1055 // Find the root of the cloned hierarchy, this means the first non cloned parent.
1056 // This will return null if first non cloned parent is not found.
1057 sp<Layer> getClonedRoot();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001058};
1059
Dominik Laskowski34157762018-10-31 13:07:19 -07001060} // namespace android
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001061
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001062#define RETURN_IF_NO_HWC_LAYER(displayDevice, ...) \
Dominik Laskowski34157762018-10-31 13:07:19 -07001063 do { \
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001064 if (!hasHwcLayer(displayDevice)) { \
Dominik Laskowski34157762018-10-31 13:07:19 -07001065 ALOGE("[%s] %s failed: no HWC layer found for display %s", mName.string(), \
Lloyd Pique37c2c9b2018-12-04 17:25:10 -08001066 __FUNCTION__, displayDevice->getDebugName().c_str()); \
Dominik Laskowski34157762018-10-31 13:07:19 -07001067 return __VA_ARGS__; \
1068 } \
1069 } while (false)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001070
1071#endif // ANDROID_LAYER_H