blob: 4cd379b963cd6b84da5f08404141ed2228a833ea [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
Dominik Laskowskib7251f42020-04-20 17:42:59 -070017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
Lloyd Piquefeb73d72018-12-04 17:23:44 -080019#include <compositionengine/LayerFE.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070020#include <gui/BufferQueue.h>
21#include <gui/ISurfaceComposerClient.h>
22#include <gui/LayerState.h>
Robert Carr720e5062018-07-30 17:45:14 -070023#include <input/InputWindow.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070024#include <layerproto/LayerProtoHeader.h>
25#include <math/vec4.h>
26#include <renderengine/Mesh.h>
27#include <renderengine/Texture.h>
Alec Mouri1c8d7202019-06-01 18:51:35 -070028#include <sys/types.h>
Lucas Dupinc3800b82020-10-02 16:24:48 -070029#include <ui/BlurRegion.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>
John Reckcdb4ed72021-02-04 13:39:33 -050035#include <ui/StretchEffect.h>
Peiyong Linefefaac2018-08-17 12:27:51 -070036#include <ui/Transform.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070037#include <utils/RefBase.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070038#include <utils/Timers.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080039
KaiChieh Chuang948c6422020-10-13 10:38:48 +080040#include <chrono>
Robert Carrcdf83202018-03-07 12:48:34 -080041#include <cstdint>
Peiyong Lincbc184f2018-08-22 13:24:10 -070042#include <list>
Dominik Laskowski075d3172018-05-24 15:50:06 -070043#include <optional>
Peiyong Lincbc184f2018-08-22 13:24:10 -070044#include <vector>
Dan Stoza7dde5992015-05-22 09:51:44 -070045
Mathias Agopian13127d82013-03-05 17:47:11 -080046#include "Client.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070047#include "ClientCache.h"
48#include "DisplayHardware/ComposerHal.h"
49#include "DisplayHardware/HWComposer.h"
Marin Shalamanove8a663d2020-11-24 17:48:00 +010050#include "Fps.h"
David Sodman41fdfc92017-11-06 16:09:56 -080051#include "FrameTracker.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070052#include "LayerVector.h"
Dan Stozab9b08832014-03-13 11:55:57 -070053#include "MonitoredProducer.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070054#include "RenderArea.h"
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010055#include "Scheduler/Seamlessness.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080056#include "SurfaceFlinger.h"
Marin Shalamanov53fc11d2020-11-20 14:00:13 +010057#include "SurfaceTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080058#include "TransactionCallbackInvoker.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080059
chaviw1d044282017-09-27 12:19:28 -070060using namespace android::surfaceflinger;
61
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080062namespace android {
63
Mathias Agopian1f7bec62010-06-25 18:02:21 -070064class Client;
Mathias Agopian3e25fd82013-04-22 17:52:16 +020065class Colorizer;
Mathias Agopian13127d82013-03-05 17:47:11 -080066class DisplayDevice;
67class GraphicBuffer;
68class SurfaceFlinger;
Kalle Raitaa099a242017-01-11 11:17:29 -080069class LayerDebugInfo;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080070
Lloyd Piquefeb73d72018-12-04 17:23:44 -080071namespace compositionengine {
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080072class OutputLayer;
Lloyd Piquea83776c2019-01-29 18:42:32 -080073struct LayerFECompositionState;
Lloyd Piquefeb73d72018-12-04 17:23:44 -080074}
75
Lloyd Pique4dccc412018-01-22 17:21:36 -080076namespace impl {
77class SurfaceInterceptor;
78}
79
Ady Abraham22c7b5c2020-09-22 19:33:40 -070080namespace frametimeline {
81class SurfaceFrame;
82} // namespace frametimeline
83
Lloyd Pique42ab75e2018-09-12 20:46:03 -070084struct LayerCreationArgs {
Dominik Laskowskib7251f42020-04-20 17:42:59 -070085 LayerCreationArgs(SurfaceFlinger*, sp<Client>, std::string name, uint32_t w, uint32_t h,
86 uint32_t flags, LayerMetadata);
Lloyd Pique42ab75e2018-09-12 20:46:03 -070087
88 SurfaceFlinger* flinger;
chaviwde94d0f2020-01-22 13:11:25 -080089 const sp<Client> client;
Dominik Laskowski87a07e42019-10-10 20:38:02 -070090 std::string name;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070091 uint32_t w;
92 uint32_t h;
93 uint32_t flags;
Evan Roskya1f1e152019-01-24 16:17:46 -080094 LayerMetadata metadata;
Dominik Laskowskib7251f42020-04-20 17:42:59 -070095
Vishnu Nair0f085c62019-08-30 08:49:12 -070096 pid_t callingPid;
97 uid_t callingUid;
chaviwb4c6e582019-08-16 14:35:07 -070098 uint32_t textureName;
Lloyd Pique42ab75e2018-09-12 20:46:03 -070099};
100
Lloyd Piquede196652020-01-22 17:29:58 -0800101class Layer : public virtual RefBase, compositionengine::LayerFE {
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700102 static std::atomic<int32_t> sSequence;
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700103 // The following constants represent priority of the window. SF uses this information when
104 // deciding which window has a priority when deciding about the refresh rate of the screen.
105 // Priority 0 is considered the highest priority. -1 means that the priority is unset.
Ana Krulecc84d09b2019-11-02 23:10:29 +0100106 static constexpr int32_t PRIORITY_UNSET = -1;
Ady Abrahamaae5ed52020-06-26 09:32:43 -0700107 // Windows that are in focus and voted for the preferred mode ID
108 static constexpr int32_t PRIORITY_FOCUSED_WITH_MODE = 0;
109 // // Windows that are in focus, but have not requested a specific mode ID.
110 static constexpr int32_t PRIORITY_FOCUSED_WITHOUT_MODE = 1;
111 // Windows that are not in focus, but voted for a specific mode ID.
112 static constexpr int32_t PRIORITY_NOT_FOCUSED_WITH_MODE = 2;
Mathias Agopian13127d82013-03-05 17:47:11 -0800113
Mathias Agopiand606de62010-05-10 20:06:11 -0700114public:
Mathias Agopian13127d82013-03-05 17:47:11 -0800115 enum { // flags for doTransaction()
116 eDontUpdateGeometryState = 0x00000001,
117 eVisibleRegion = 0x00000002,
Robert Carr720e5062018-07-30 17:45:14 -0700118 eInputInfoChanged = 0x00000004
Mathias Agopian13127d82013-03-05 17:47:11 -0800119 };
120
121 struct Geometry {
122 uint32_t w;
123 uint32_t h;
Peiyong Linefefaac2018-08-17 12:27:51 -0700124 ui::Transform transform;
Robert Carr3dcabfa2016-03-01 18:36:58 -0800125
David Sodman41fdfc92017-11-06 16:09:56 -0800126 inline bool operator==(const Geometry& rhs) const {
127 return (w == rhs.w && h == rhs.h) && (transform.tx() == rhs.transform.tx()) &&
Robert Carr99e27f02016-06-16 15:18:02 -0700128 (transform.ty() == rhs.transform.ty());
Mathias Agopian13127d82013-03-05 17:47:11 -0800129 }
David Sodman41fdfc92017-11-06 16:09:56 -0800130 inline bool operator!=(const Geometry& rhs) const { return !operator==(rhs); }
Mathias Agopian13127d82013-03-05 17:47:11 -0800131 };
132
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700133 struct RoundedCornerState {
134 RoundedCornerState() = default;
135 RoundedCornerState(FloatRect cropRect, float radius)
136 : cropRect(cropRect), radius(radius) {}
137
138 // Rounded rectangle in local layer coordinate space.
139 FloatRect cropRect = FloatRect();
140 // Radius of the rounded rectangle.
141 float radius = 0.0f;
142 };
143
Ady Abraham71c437d2020-01-31 15:56:57 -0800144 // FrameRateCompatibility specifies how we should interpret the frame rate associated with
145 // the layer.
146 enum class FrameRateCompatibility {
147 Default, // Layer didn't specify any specific handling strategy
148
Ady Abrahamdd5bfa92021-01-07 17:56:08 -0800149 Exact, // Layer needs the exact frame rate.
150
Ady Abraham71c437d2020-01-31 15:56:57 -0800151 ExactOrMultiple, // Layer needs the exact frame rate (or a multiple of it) to present the
152 // content properly. Any other value will result in a pull down.
153
154 NoVote, // Layer doesn't have any requirements for the refresh rate and
155 // should not be considered when the display refresh rate is determined.
156 };
157
158 // Encapsulates the frame rate and compatibility of the layer. This information will be used
159 // when the display refresh rate is determined.
160 struct FrameRate {
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100161 using Seamlessness = scheduler::Seamlessness;
162
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100163 Fps rate;
Ady Abraham71c437d2020-01-31 15:56:57 -0800164 FrameRateCompatibility type;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100165 Seamlessness seamlessness;
Ady Abraham71c437d2020-01-31 15:56:57 -0800166
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100167 FrameRate()
168 : rate(0),
169 type(FrameRateCompatibility::Default),
170 seamlessness(Seamlessness::Default) {}
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100171 FrameRate(Fps rate, FrameRateCompatibility type, bool shouldBeSeamless = true)
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100172 : rate(rate), type(type), seamlessness(getSeamlessness(rate, shouldBeSeamless)) {}
Ady Abraham71c437d2020-01-31 15:56:57 -0800173
174 bool operator==(const FrameRate& other) const {
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100175 return rate.equalsWithMargin(other.rate) && type == other.type &&
176 seamlessness == other.seamlessness;
Ady Abraham71c437d2020-01-31 15:56:57 -0800177 }
178
179 bool operator!=(const FrameRate& other) const { return !(*this == other); }
Steven Thomas62a4cf82020-01-31 12:04:03 -0800180
181 // Convert an ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value to a
182 // Layer::FrameRateCompatibility. Logs fatal if the compatibility value is invalid.
183 static FrameRateCompatibility convertCompatibility(int8_t compatibility);
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100184
185 private:
Marin Shalamanove8a663d2020-11-24 17:48:00 +0100186 static Seamlessness getSeamlessness(Fps rate, bool shouldBeSeamless) {
187 if (!rate.isValid()) {
Marin Shalamanov53fc11d2020-11-20 14:00:13 +0100188 // Refresh rate of 0 is a special value which should reset the vote to
189 // its default value.
190 return Seamlessness::Default;
191 } else if (shouldBeSeamless) {
192 return Seamlessness::OnlySeamless;
193 } else {
194 return Seamlessness::SeamedAndSeamless;
195 }
196 }
Ady Abraham71c437d2020-01-31 15:56:57 -0800197 };
198
Mathias Agopian13127d82013-03-05 17:47:11 -0800199 struct State {
Marissa Wallf58c14b2018-07-24 10:50:43 -0700200 Geometry active_legacy;
201 Geometry requested_legacy;
Robert Carrae060832016-11-28 10:51:00 -0800202 int32_t z;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800203
204 // The identifier of the layer stack this layer belongs to. A layer can
205 // only be associated to a single layer stack. A layer stack is a
206 // z-ordered group of layers which can be associated to one or more
207 // displays. Using the same layer stack on different displays is a way
208 // to achieve mirroring.
Mathias Agopian13127d82013-03-05 17:47:11 -0800209 uint32_t layerStack;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800210
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800211 uint32_t flags;
Mathias Agopian13127d82013-03-05 17:47:11 -0800212 uint8_t reserved[2];
213 int32_t sequence; // changes when visible regions can change
Dan Stoza7dde5992015-05-22 09:51:44 -0700214 bool modified;
215
Fabien Sanglard4ed383c2016-12-13 14:02:41 -0800216 // Crop is expressed in layer space coordinate.
chaviw25714502021-02-11 10:01:08 -0800217 Rect crop;
218 Rect requestedCrop;
Robert Carr99e27f02016-06-16 15:18:02 -0700219
Robert Carr0d480722017-01-10 16:42:54 -0800220 // If set, defers this state update until the identified Layer
Dan Stoza7dde5992015-05-22 09:51:44 -0700221 // receives a frame with the given frameNumber
Marissa Wallf58c14b2018-07-24 10:50:43 -0700222 wp<Layer> barrierLayer_legacy;
Vishnu Nair6b7c5c92020-09-29 17:27:05 -0700223 uint64_t barrierFrameNumber;
Dan Stoza7dde5992015-05-22 09:51:44 -0700224
Mathias Agopian2ca79392013-04-02 18:30:32 -0700225 // the transparentRegion hint is a bit special, it's latched only
226 // when we receive a buffer -- this is because it's "content"
227 // dependent.
Marissa Wallf58c14b2018-07-24 10:50:43 -0700228 Region activeTransparentRegion_legacy;
229 Region requestedTransparentRegion_legacy;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500230
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800231 LayerMetadata metadata;
Robert Carrdb66e622017-04-10 16:55:57 -0700232
233 // If non-null, a Surface this Surface's Z-order is interpreted relative to.
234 wp<Layer> zOrderRelativeOf;
chaviwe5ac40f2019-09-24 16:36:55 -0700235 bool isRelativeOf{false};
Robert Carrdb66e622017-04-10 16:55:57 -0700236
237 // A list of surfaces whose Z-order is interpreted relative to ours.
238 SortedVector<wp<Layer>> zOrderRelatives;
chaviw13fdc492017-06-27 12:40:18 -0700239
240 half4 color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700241 float cornerRadius;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800242 int backgroundBlurRadius;
Marissa Wall61c58622018-07-18 10:12:20 -0700243
Robert Carr720e5062018-07-30 17:45:14 -0700244 bool inputInfoChanged;
245 InputWindowInfo inputInfo;
Vishnu Nair6fabeec2019-03-12 13:42:49 -0700246 wp<Layer> touchableRegionCrop;
Robert Carr720e5062018-07-30 17:45:14 -0700247
Vishnu Nairfa247b12020-02-11 08:58:26 -0800248 // dataspace is only used by BufferStateLayer and EffectLayer
Valerie Haub153bab2019-03-05 10:47:28 -0800249 ui::Dataspace dataspace;
250
Marissa Wall61c58622018-07-18 10:12:20 -0700251 // The fields below this point are only used by BufferStateLayer
Valerie Hau134651a2020-01-28 16:21:22 -0800252 uint64_t frameNumber;
chaviw766c9c52021-02-10 17:36:47 -0800253 uint32_t width;
254 uint32_t height;
255 ui::Transform transform;
Marissa Wall61c58622018-07-18 10:12:20 -0700256
chaviw766c9c52021-02-10 17:36:47 -0800257 uint32_t bufferTransform;
Marissa Wall61c58622018-07-18 10:12:20 -0700258 bool transformToDisplayInverse;
259
Marissa Wall61c58622018-07-18 10:12:20 -0700260 Region transparentRegionHint;
261
262 sp<GraphicBuffer> buffer;
Marissa Wall947d34e2019-03-29 14:03:53 -0700263 client_cache_t clientCacheId;
Marissa Wall61c58622018-07-18 10:12:20 -0700264 sp<Fence> acquireFence;
Marissa Wall61c58622018-07-18 10:12:20 -0700265 HdrMetadata hdrMetadata;
266 Region surfaceDamageRegion;
267 int32_t api;
268
269 sp<NativeHandle> sidebandStream;
Peiyong Lind3788632018-09-18 16:01:31 -0700270 mat4 colorTransform;
Peiyong Lin747321c2018-10-01 10:03:11 -0700271 bool hasColorTransform;
Marissa Walle2ffb422018-10-12 11:33:52 -0700272
Valerie Haua72e2812019-01-23 13:40:39 -0800273 // pointer to background color layer that, if set, appears below the buffer state layer
274 // and the buffer state layer's children. Z order will be set to
275 // INT_MIN
276 sp<Layer> bgColorLayer;
Valerie Haued54efa2019-01-11 20:03:14 -0800277
Marissa Walle2ffb422018-10-12 11:33:52 -0700278 // The deque of callback handles for this frame. The back of the deque contains the most
279 // recent callback handle.
280 std::deque<sp<CallbackHandle>> callbackHandles;
Peiyong Linc502cb72019-03-01 15:00:23 -0800281 bool colorSpaceAgnostic;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800282 nsecs_t desiredPresentTime = 0;
283 bool isAutoTimestamp = true;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800284
285 // Length of the cast shadow. If the radius is > 0, a shadow of length shadowRadius will
286 // be rendered around the layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700287 float shadowRadius;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100288
Lucas Dupinc3800b82020-10-02 16:24:48 -0700289 // Layer regions that are made of custom materials, like frosted glass
290 std::vector<BlurRegion> blurRegions;
291
Ana Krulecc84d09b2019-11-02 23:10:29 +0100292 // Priority of the layer assigned by Window Manager.
293 int32_t frameRateSelectionPriority;
Steven Thomas3172e202020-01-06 19:25:30 -0800294
Ady Abraham71c437d2020-01-31 15:56:57 -0800295 FrameRate frameRate;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700296
297 // Indicates whether parents / children of this layer had set FrameRate
298 bool treeHasFrameRateVote;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700299
300 // Set by window manager indicating the layer and all its children are
301 // in a different orientation than the display. The hint suggests that
302 // the graphic producers should receive a transform hint as if the
303 // display was in this orientation. When the display changes to match
304 // the layer orientation, the graphic producer may not need to allocate
305 // a buffer of a different size. ui::Transform::ROT_INVALID means the
306 // a fixed transform hint is not set.
307 ui::Transform::RotationFlags fixedTransformHint;
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700308
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000309 // The vsync info that was used to start the transaction
310 FrameTimelineInfo frameTimelineInfo;
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700311
312 // When the transaction was posted
313 nsecs_t postTime;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000314
Vishnu Nair1506b182021-02-22 14:35:15 -0800315 sp<ITransactionCompletedListener> releaseBufferListener;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000316 // SurfaceFrame that tracks the timeline of Transactions that contain a Buffer. Only one
317 // such SurfaceFrame exists because only one buffer can be presented on the layer per vsync.
318 // If multiple buffers are queued, the prior ones will be dropped, along with the
319 // SurfaceFrame that's tracking them.
320 std::shared_ptr<frametimeline::SurfaceFrame> bufferSurfaceFrameTX;
321 // A map of token(frametimelineVsyncId) to the SurfaceFrame that's tracking a transaction
322 // that contains the token. Only one SurfaceFrame exisits for transactions that share the
323 // same token, unless they are presented in different vsyncs.
324 std::unordered_map<int64_t, std::shared_ptr<frametimeline::SurfaceFrame>>
325 bufferlessSurfaceFramesTX;
326 // An arbitrary threshold for the number of BufferlessSurfaceFrames in the state. Used to
327 // trigger a warning if the number of SurfaceFrames crosses the threshold.
328 static constexpr uint32_t kStateSurfaceFramesThreshold = 25;
John Reckcdb4ed72021-02-04 13:39:33 -0500329
330 // Stretch effect to apply to this layer
331 StretchEffect stretchEffect;
Mathias Agopian13127d82013-03-05 17:47:11 -0800332 };
333
Peiyong Linf243e5e2020-08-22 17:40:59 -0700334 /*
335 * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
336 * is called.
337 */
338 class LayerCleaner {
339 sp<SurfaceFlinger> mFlinger;
340 sp<Layer> mLayer;
341
342 protected:
343 ~LayerCleaner() {
344 // destroy client resources
345 mFlinger->onHandleDestroyed(mLayer);
346 }
347
348 public:
349 LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
350 : mFlinger(flinger), mLayer(layer) {}
351 };
352
353 /*
354 * The layer handle is just a BBinder object passed to the client
355 * (remote process) -- we don't keep any reference on our side such that
356 * the dtor is called when the remote side let go of its reference.
357 *
358 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
359 * this layer when the handle is destroyed.
360 */
361 class Handle : public BBinder, public LayerCleaner {
362 public:
363 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
364 : LayerCleaner(flinger, layer), owner(layer) {}
365
366 wp<Layer> owner;
367 };
368
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700369 explicit Layer(const LayerCreationArgs& args);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700370 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800371
Peiyong Linf243e5e2020-08-22 17:40:59 -0700372 static bool isLayerFocusedBasedOnPriority(int32_t priority);
373 static void miniDumpHeader(std::string& result);
374 static std::string frameRateCompatibilityString(FrameRateCompatibility compatibility);
Dominik Laskowski75848362019-11-11 17:57:20 -0800375
Peiyong Linf243e5e2020-08-22 17:40:59 -0700376 // Provide unique string for each class type in the Layer hierarchy
377 virtual const char* getType() const = 0;
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700378
Peiyong Linf243e5e2020-08-22 17:40:59 -0700379 // true if this layer is visible, false otherwise
380 virtual bool isVisible() const = 0;
Chia-I Wuab0c3192017-08-01 11:29:00 -0700381
Peiyong Linf243e5e2020-08-22 17:40:59 -0700382 virtual sp<Layer> createClone() = 0;
383
Robert Carr7bf247e2017-05-18 14:02:49 -0700384 // Geometry setting functions.
385 //
386 // The following group of functions are used to specify the layers
387 // bounds, and the mapping of the texture on to those bounds. According
388 // to various settings changes to them may apply immediately, or be delayed until
389 // a pending resize is completed by the producer submitting a buffer. For example
390 // if we were to change the buffer size, and update the matrix ahead of the
391 // new buffer arriving, then we would be stretching the buffer to a different
392 // aspect before and after the buffer arriving, which probably isn't what we wanted.
393 //
394 // The first set of geometry functions are controlled by the scaling mode, described
395 // in window.h. The scaling mode may be set by the client, as it submits buffers.
Robert Carr7bf247e2017-05-18 14:02:49 -0700396 //
397 // Put simply, if our scaling mode is SCALING_MODE_FREEZE, then
398 // matrix updates will not be applied while a resize is pending
399 // and the size and transform will remain in their previous state
400 // until a new buffer is submitted. If the scaling mode is another value
401 // then the old-buffer will immediately be scaled to the pending size
402 // and the new matrix will be immediately applied following this scaling
403 // transformation.
Robert Carr8d5227b2017-03-16 15:41:03 -0700404
Robert Carr7bf247e2017-05-18 14:02:49 -0700405 // Set the default buffer size for the assosciated Producer, in pixels. This is
406 // also the rendered size of the layer prior to any transformations. Parent
407 // or local matrix transformations will not affect the size of the buffer,
408 // but may affect it's on-screen size or clipping.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800409 virtual bool setSize(uint32_t w, uint32_t h);
Robert Carr7bf247e2017-05-18 14:02:49 -0700410 // Set a 2x2 transformation matrix on the layer. This transform
411 // will be applied after parent transforms, but before any final
412 // producer specified transform.
Marissa Wall61c58622018-07-18 10:12:20 -0700413 virtual bool setMatrix(const layer_state_t::matrix22_t& matrix,
414 bool allowNonRectPreservingTransforms);
Robert Carr7bf247e2017-05-18 14:02:49 -0700415
416 // This second set of geometry attributes are controlled by
417 // setGeometryAppliesWithResize, and their default mode is to be
418 // immediate. If setGeometryAppliesWithResize is specified
419 // while a resize is pending, then update of these attributes will
420 // be delayed until the resize completes.
421
422 // setPosition operates in parent buffer space (pre parent-transform) or display
423 // space for top-level layers.
chaviw214c89d2019-09-04 16:03:53 -0700424 virtual bool setPosition(float x, float y);
Robert Carr7bf247e2017-05-18 14:02:49 -0700425 // Buffer space
chaviw25714502021-02-11 10:01:08 -0800426 virtual bool setCrop(const Rect& crop);
Robert Carr8d5227b2017-03-16 15:41:03 -0700427
Robert Carr7bf247e2017-05-18 14:02:49 -0700428 // TODO(b/38182121): Could we eliminate the various latching modes by
429 // using the layer hierarchy?
430 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800431 virtual bool setLayer(int32_t z);
432 virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carrdb66e622017-04-10 16:55:57 -0700433
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800434 virtual bool setAlpha(float alpha);
Valerie Haudd0b7572019-01-29 14:59:27 -0800435 virtual bool setColor(const half3& /*color*/) { return false; };
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700436
437 // Set rounded corner radius for this layer and its children.
438 //
439 // We only support 1 radius per layer in the hierarchy, where parent layers have precedence.
440 // The shape of the rounded corner rectangle is specified by the crop rectangle of the layer
441 // from which we inferred the rounded corner radius.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800442 virtual bool setCornerRadius(float cornerRadius);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800443 // When non-zero, everything below this layer will be blurred by backgroundBlurRadius, which
444 // is specified in pixels.
445 virtual bool setBackgroundBlurRadius(int backgroundBlurRadius);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700446 virtual bool setBlurRegions(const std::vector<BlurRegion>& effectRegions);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800447 virtual bool setTransparentRegionHint(const Region& transparent);
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800448 virtual bool setFlags(uint32_t flags, uint32_t mask);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800449 virtual bool setLayerStack(uint32_t layerStack);
450 virtual uint32_t getLayerStack() const;
Marissa Wall61c58622018-07-18 10:12:20 -0700451 virtual void deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle,
452 uint64_t frameNumber);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800453 virtual void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber);
Evan Roskyef876c92019-01-25 17:46:06 -0800454 virtual bool setMetadata(const LayerMetadata& data);
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200455 virtual void setChildrenDrawingParent(const sp<Layer>&);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800456 virtual bool reparent(const sp<IBinder>& newParentHandle);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800457 virtual bool setColorTransform(const mat4& matrix);
458 virtual mat4 getColorTransform() const;
459 virtual bool hasColorTransform() const;
Peiyong Linc502cb72019-03-01 15:00:23 -0800460 virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; }
Marissa Wall61c58622018-07-18 10:12:20 -0700461
462 // Used only to set BufferStateLayer state
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800463 virtual bool setTransform(uint32_t /*transform*/) { return false; };
464 virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };
Valerie Haubf784642020-01-29 07:25:23 -0800465 virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/, const sp<Fence>& /*acquireFence*/,
466 nsecs_t /*postTime*/, nsecs_t /*desiredPresentTime*/,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800467 bool /*isAutoTimestamp*/, const client_cache_t& /*clientCacheId*/,
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000468 uint64_t /* frameNumber */, std::optional<nsecs_t> /* dequeueTime */,
Vishnu Nair1506b182021-02-22 14:35:15 -0800469 const FrameTimelineInfo& /*info*/,
470 const sp<ITransactionCompletedListener>& /* releaseBufferListener */) {
Ady Abraham09bd3922019-04-08 10:44:56 -0700471 return false;
Marissa Wall947d34e2019-03-29 14:03:53 -0700472 };
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800473 virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };
474 virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };
475 virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };
476 virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) { return false; };
477 virtual bool setApi(int32_t /*api*/) { return false; };
478 virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };
Marissa Walle2ffb422018-10-12 11:33:52 -0700479 virtual bool setTransactionCompletedListeners(
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800480 const std::vector<sp<CallbackHandle>>& /*handles*/) {
Marissa Walle2ffb422018-10-12 11:33:52 -0700481 return false;
482 };
Valerie Hau871d6352020-01-29 08:44:02 -0800483 virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/,
484 nsecs_t /*requestedPresentTime*/) {
485 return false;
486 }
Valerie Haudd0b7572019-01-29 14:59:27 -0800487 virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace);
Peiyong Linc502cb72019-03-01 15:00:23 -0800488 virtual bool setColorSpaceAgnostic(const bool agnostic);
Ana Krulecc84d09b2019-11-02 23:10:29 +0100489 virtual bool setFrameRateSelectionPriority(int32_t priority);
Vishnu Nair6213bd92020-05-08 17:42:25 -0700490 virtual bool setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint);
Vishnu Naircf26a0a2020-11-13 12:56:20 -0800491 virtual void setAutoRefresh(bool /* autoRefresh */) {}
Ana Krulecc84d09b2019-11-02 23:10:29 +0100492 // If the variable is not set on the layer, it traverses up the tree to inherit the frame
493 // rate priority from its parent.
494 virtual int32_t getFrameRateSelectionPriority() const;
chaviw4244e032019-09-04 11:27:49 -0700495 virtual ui::Dataspace getDataSpace() const { return ui::Dataspace::UNKNOWN; }
Chia-I Wu01591c92018-05-22 12:03:00 -0700496
Lloyd Piquede196652020-01-22 17:29:58 -0800497 virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const;
498 virtual compositionengine::LayerFECompositionState* editCompositionState();
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800499
Dan Stozaee44edd2015-03-23 15:50:23 -0700500 // If we have received a new buffer this frame, we will pass its surface
501 // damage down to hardware composer. Otherwise, we must send a region with
502 // one empty rect.
Robert Carr105e64b2018-03-07 12:47:50 -0800503 virtual void useSurfaceDamage() {}
504 virtual void useEmptyDamage() {}
Alec Mouriadebf5c2021-01-05 12:57:36 -0800505 Region getVisibleRegion(const DisplayDevice*) const;
Dan Stozaee44edd2015-03-23 15:50:23 -0700506
Peiyong Linf243e5e2020-08-22 17:40:59 -0700507 /*
508 * isOpaque - true if this surface is opaque
509 *
510 * This takes into account the buffer format (i.e. whether or not the
511 * pixel format includes an alpha channel) and the "opaque" flag set
512 * on the layer. It does not examine the current plane alpha value.
513 */
514 virtual bool isOpaque(const Layer::State&) const { return false; }
515
516 /*
517 * Returns whether this layer can receive input.
518 */
519 virtual bool canReceiveInput() const;
520
521 /*
Peiyong Lin05cc0112020-10-14 16:16:37 -0700522 * isProtected - true if the layer may contain protected contents in the
Peiyong Linf243e5e2020-08-22 17:40:59 -0700523 * GRALLOC_USAGE_PROTECTED sense.
524 */
525 virtual bool isProtected() const { return false; }
526
527 /*
528 * isFixedSize - true if content has a fixed size
529 */
530 virtual bool isFixedSize() const { return true; }
531
532 /*
533 * usesSourceCrop - true if content should use a source crop
534 */
535 virtual bool usesSourceCrop() const { return false; }
536
537 // Most layers aren't created from the main thread, and therefore need to
538 // grab the SF state lock to access HWC, but ContainerLayer does, so we need
539 // to avoid grabbing the lock again to avoid deadlock
540 virtual bool isCreatedFromMainThread() const { return false; }
541
542 virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }
543 virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }
544 virtual uint32_t getActiveHeight(const Layer::State& s) const { return s.active_legacy.h; }
545 virtual ui::Transform getActiveTransform(const Layer::State& s) const {
546 return s.active_legacy.transform;
547 }
548 virtual Region getActiveTransparentRegion(const Layer::State& s) const {
549 return s.activeTransparentRegion_legacy;
550 }
chaviw25714502021-02-11 10:01:08 -0800551 virtual Rect getCrop(const Layer::State& s) const { return s.crop; }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700552 virtual bool needsFiltering(const DisplayDevice*) const { return false; }
553
554 // True if this layer requires filtering
555 // This method is distinct from needsFiltering() in how the filter
556 // requirement is computed. needsFiltering() compares displayFrame and crop,
557 // where as this method transforms the displayFrame to layer-stack space
558 // first. This method should be used if there is no physical display to
559 // project onto when taking screenshots, as the filtering requirements are
560 // different.
561 // If the parent transform needs to be undone when capturing the layer, then
562 // the inverse parent transform is also required.
563 virtual bool needsFilteringForScreenshots(const DisplayDevice*, const ui::Transform&) const {
564 return false;
565 }
566
567 virtual void updateCloneBufferInfo(){};
568
569 virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {}
570
571 virtual bool isHdrY410() const { return false; }
572
573 virtual bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const { return false; }
574
Vishnu Nair6b7c5c92020-09-29 17:27:05 -0700575 virtual uint64_t getHeadFrameNumber(nsecs_t /* expectedPresentTime */) const { return 0; }
576
Peiyong Linf243e5e2020-08-22 17:40:59 -0700577 /*
578 * called after composition.
579 * returns true if the layer latched a new buffer this frame.
580 */
581 virtual bool onPostComposition(const DisplayDevice*,
582 const std::shared_ptr<FenceTime>& /*glDoneFence*/,
583 const std::shared_ptr<FenceTime>& /*presentFence*/,
584 const CompositorTiming&) {
585 return false;
586 }
587
588 // If a buffer was replaced this frame, release the former buffer
589 virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { }
590
591 virtual void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& /*glDoneFence*/,
592 const CompositorTiming& /*compositorTiming*/) {}
593
594 /*
595 * latchBuffer - called each time the screen is redrawn and returns whether
596 * the visible regions need to be recomputed (this is a fairly heavy
597 * operation, so this should be set only if needed). Typically this is used
598 * to figure out if the content or size of a surface has changed.
599 */
600 virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
601 nsecs_t /*expectedPresentTime*/) {
602 return false;
603 }
604
605 virtual bool isBufferLatched() const { return false; }
606
607 virtual void latchAndReleaseBuffer() {}
608
609 /*
610 * returns the rectangle that crops the content of the layer and scales it
611 * to the layer's size.
612 */
613 virtual Rect getBufferCrop() const { return Rect(); }
614
615 /*
616 * Returns the transform applied to the buffer.
617 */
618 virtual uint32_t getBufferTransform() const { return 0; }
619
620 virtual sp<GraphicBuffer> getBuffer() const { return nullptr; }
621
622 virtual ui::Transform::RotationFlags getTransformHint() const { return ui::Transform::ROT_0; }
623
624 /*
625 * Returns if a frame is ready
626 */
627 virtual bool hasReadyFrame() const { return false; }
628
629 virtual int32_t getQueuedFrameCount() const { return 0; }
630
631 virtual void pushPendingState();
632
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000633 /*
634 * Merges the BufferlessSurfaceFrames from source with the target. If the same token exists in
635 * both source and target, target's SurfaceFrame will be retained.
636 */
637 void mergeSurfaceFrames(State& source, State& target);
638
Peiyong Linf243e5e2020-08-22 17:40:59 -0700639 /**
640 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing
641 * any buffer transformations. If the layer has no buffer then return INVALID_RECT.
642 */
643 virtual Rect getBufferSize(const Layer::State&) const { return Rect::INVALID_RECT; }
644
645 /**
646 * Returns the source bounds. If the bounds are not defined, it is inferred from the
647 * buffer size. Failing that, the bounds are determined from the passed in parent bounds.
648 * For the root layer, this is the display viewport size.
649 */
650 virtual FloatRect computeSourceBounds(const FloatRect& parentBounds) const {
651 return parentBounds;
652 }
653 virtual FrameRate getFrameRateForLayerTree() const;
654
655 virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) {
656 return {};
657 }
658
659 virtual bool getTransformToDisplayInverse() const { return false; }
660
661 // Returns how rounded corners should be drawn for this layer.
662 // This will traverse the hierarchy until it reaches its root, finding topmost rounded
663 // corner definition and converting it into current layer's coordinates.
664 // As of now, only 1 corner radius per display list is supported. Subsequent ones will be
665 // ignored.
666 virtual RoundedCornerState getRoundedCornerState() const;
667
668 virtual void notifyAvailableFrames(nsecs_t /*expectedPresentTime*/) {}
669 virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; }
670 /**
671 * Return whether this layer needs an input info. For most layer types
672 * this is only true if they explicitly set an input-info but BufferLayer
673 * overrides this so we can generate input-info for Buffered layers that don't
674 * have them (for input occlusion detection checks).
675 */
676 virtual bool needsInputInfo() const { return hasInputInfo(); }
677
678 // Implements RefBase.
679 void onFirstRef() override;
680
681 // implements compositionengine::LayerFE
682 const compositionengine::LayerFECompositionState* getCompositionState() const override;
683 bool onPreComposition(nsecs_t) override;
684 void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override;
685 std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList(
686 compositionengine::LayerFE::ClientCompositionTargetSettings&) override;
687 void onLayerDisplayed(const sp<Fence>& releaseFence) override;
688 const char* getDebugName() const override;
689
690 bool reparentChildren(const sp<IBinder>& newParentHandle);
691 void reparentChildren(const sp<Layer>& newParent);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700692 bool setShadowRadius(float shadowRadius);
693
694 // Before color management is introduced, contents on Android have to be
695 // desaturated in order to match what they appears like visually.
696 // With color management, these contents will appear desaturated, thus
697 // needed to be saturated so that they match what they are designed for
698 // visually.
699 bool isLegacyDataSpace() const;
700
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800701 uint32_t getTransactionFlags() const { return mTransactionFlags; }
702 uint32_t getTransactionFlags(uint32_t flags);
703 uint32_t setTransactionFlags(uint32_t flags);
Mathias Agopian13127d82013-03-05 17:47:11 -0800704
Lloyd Piqueef36b002019-01-23 17:52:04 -0800705 // Deprecated, please use compositionengine::Output::belongsInOutput()
706 // instead.
707 // TODO(lpique): Move the remaining callers (screencap) to the new function.
chaviw4b9d5e12020-08-04 18:30:35 -0700708 bool belongsToDisplay(uint32_t layerStack) const { return getLayerStack() == layerStack; }
Chia-I Wuab0c3192017-08-01 11:29:00 -0700709
Vishnu Nair4351ad52019-02-11 14:13:02 -0800710 FloatRect getBounds(const Region& activeTransparentRegion) const;
711 FloatRect getBounds() const;
712
713 // Compute bounds for the layer and cache the results.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700714 void computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float shadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800715
Vishnu Nairc652ff82019-03-15 12:48:54 -0700716 // Returns the buffer scale transform if a scaling mode is set.
717 ui::Transform getBufferScaleTransform() const;
718
Vishnu Nair4351ad52019-02-11 14:13:02 -0800719 // Get effective layer transform, taking into account all its parent transform with any
720 // scaling if the parent scaling more is not NATIVE_WINDOW_SCALING_MODE_FREEZE.
Vishnu Nairc652ff82019-03-15 12:48:54 -0700721 ui::Transform getTransformWithScale(const ui::Transform& bufferScaleTransform) const;
722
723 // Returns the bounds of the layer without any buffer scaling.
724 FloatRect getBoundsPreScaling(const ui::Transform& bufferScaleTransform) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800725
Dan Stoza269dc4d2021-01-15 15:07:43 -0800726 int32_t getSequence() const override { return sequence; }
Pablo Ceballos40845df2016-01-25 17:41:15 -0800727
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700728 // For tracing.
729 // TODO: Replace with raw buffer id from buffer metadata when that becomes available.
730 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces
731 // creates its tracks by buffer id and has no way of associating a buffer back to the process
732 // that created it, the current implementation is only sufficient for cases where a buffer is
733 // only used within a single layer.
chaviwd62d3062019-09-04 14:48:02 -0700734 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; }
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700735
Mathias Agopian13127d82013-03-05 17:47:11 -0800736 /*
737 * isSecure - true if this surface is secure, that is if it prevents
Peiyong Lin05cc0112020-10-14 16:16:37 -0700738 * screenshots or VNC servers. A surface can be set to be secure by the
739 * application, being secure doesn't mean the surface has DRM contents.
Mathias Agopian13127d82013-03-05 17:47:11 -0800740 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800741 bool isSecure() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800742
743 /*
Robert Carr1f0a16a2016-10-24 16:27:39 -0700744 * isHiddenByPolicy - true if this layer has been forced invisible.
745 * just because this is false, doesn't mean isVisible() is true.
746 * For example if this layer has no active buffer, it may not be hidden by
747 * policy, but it still can not be visible.
748 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800749 bool isHiddenByPolicy() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700750
Robert Carr2e102c92018-10-23 12:11:15 -0700751 bool isRemovedFromCurrentState() const;
chaviw8b3871a2017-11-01 17:41:01 -0700752
chaviw4c34a092020-07-08 11:30:06 -0700753 LayerProto* writeToProto(LayersProto& layersProto, uint32_t traceFlags, const DisplayDevice*);
chaviw08f3cb22020-01-13 13:17:21 -0800754
Vishnu Nair8406fd72019-07-30 11:29:31 -0700755 // Write states that are modified by the main thread. This includes drawing
756 // state as well as buffer data. This should be called in the main or tracing
757 // thread.
chaviw4c34a092020-07-08 11:30:06 -0700758 void writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags, const DisplayDevice*);
Vishnu Nair8406fd72019-07-30 11:29:31 -0700759 // Write drawing or current state. If writing current state, the caller should hold the
760 // external mStateLock. If writing drawing state, this function should be called on the
761 // main or tracing thread.
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200762 void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet,
chaviw4c34a092020-07-08 11:30:06 -0700763 uint32_t traceFlags = SurfaceTracing::TRACE_ALL);
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800764
Peiyong Linf243e5e2020-08-22 17:40:59 -0700765 InputWindowInfo::Type getWindowType() const { return mWindowType; }
Peiyong Lin97067b02019-03-29 17:34:45 +0000766
chaviwc5676c62020-09-18 15:01:04 -0700767 bool getPrimaryDisplayOnly() const;
chaviwb4c6e582019-08-16 14:35:07 -0700768
chaviw74b03172019-08-19 11:09:03 -0700769 void updateMirrorInfo();
chaviw74b03172019-08-19 11:09:03 -0700770
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700771 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700772 * doTransaction - process the transaction. This is a good place to figure
773 * out which attributes of the surface have changed.
774 */
Robert Carr7121caf2020-12-15 13:07:32 -0800775 virtual uint32_t doTransaction(uint32_t transactionFlags);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700776
777 /*
Vishnu Nair1506b182021-02-22 14:35:15 -0800778 * Called before updating the drawing state buffer. Used by BufferStateLayer to release any
779 * unlatched buffers in the drawing state.
780 */
781 virtual void bufferMayChange(sp<GraphicBuffer>& /* newBuffer */){};
782
783 /*
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700784 * Remove relative z for the layer if its relative parent is not part of the
785 * provided layer tree.
786 */
787 void removeRelativeZ(const std::vector<Layer*>& layersInTree);
788
789 /*
790 * Remove from current state and mark for removal.
791 */
792 void removeFromCurrentState();
793
794 /*
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800795 * called with the state lock from a binder thread when the layer is
Chia-I Wuc6657022017-08-15 11:18:17 -0700796 * removed from the current list to the pending removal list
797 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800798 void onRemovedFromCurrentState();
Chia-I Wuc6657022017-08-15 11:18:17 -0700799
chaviw61626f22018-11-15 16:26:27 -0800800 /*
801 * Called when the layer is added back to the current state list.
802 */
803 void addToCurrentState();
804
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700805 /*
806 * Sets display transform hint on BufferLayerConsumer.
807 */
808 void updateTransformHint(ui::Transform::RotationFlags);
Andy McFadden69052052012-09-14 16:10:11 -0700809
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800810 inline const State& getDrawingState() const { return mDrawingState; }
811 inline const State& getCurrentState() const { return mCurrentState; }
812 inline State& getCurrentState() { return mCurrentState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800813
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700814 LayerDebugInfo getLayerDebugInfo(const DisplayDevice*) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800815
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700816 void miniDump(std::string& result, const DisplayDevice&) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800817 void dumpFrameStats(std::string& result) const;
818 void dumpFrameEvents(std::string& result);
Vishnu Nair0f085c62019-08-30 08:49:12 -0700819 void dumpCallingUidPid(std::string& result) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700820 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700821 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700822 void getFrameStats(FrameStats* outStats) const;
Brian Anderson5ea5e592016-12-01 16:54:33 -0800823 void onDisconnect();
Brian Anderson3890c392016-07-25 12:48:08 -0700824 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
David Sodman41fdfc92017-11-06 16:09:56 -0800825 FrameEventHistoryDelta* outDelta);
Pablo Ceballosce796e72016-02-04 19:10:51 -0800826
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800827 ui::Transform getTransform() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700828
Robert Carr6452f122017-03-21 10:41:29 -0700829 // Returns the Alpha of the Surface, accounting for the Alpha
830 // of parent Surfaces in the hierarchy (alpha's will be multiplied
831 // down the hierarchy).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800832 half getAlpha() const;
833 half4 getColor() const;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800834 int32_t getBackgroundBlurRadius() const;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800835 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; };
Robert Carr6452f122017-03-21 10:41:29 -0700836
Vishnu Nair6213bd92020-05-08 17:42:25 -0700837 // Returns the transform hint set by Window Manager on the layer or one of its parents.
838 // This traverses the current state because the data is needed when creating
839 // the layer(off drawing thread) and the hint should be available before the producer
840 // is ready to acquire a buffer.
841 ui::Transform::RotationFlags getFixedTransformHint() const;
842
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200843 renderengine::ShadowSettings getShadowSettings(const Rect& layerStackRect) const;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800844
Edgar Arriaga844fa672020-01-16 14:21:42 -0800845 /**
846 * Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder
847 * which will not emit children who have relativeZOrder to another layer, this method
848 * just directly emits all children. It also emits them in no particular order.
849 * So this method is not suitable for graphical operations, as it doesn't represent
850 * the scene state, but it's also more efficient than traverseInZOrder and so useful for
851 * book-keeping.
852 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200853 void traverse(LayerVector::StateSet, const LayerVector::Visitor&);
854 void traverseInReverseZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
855 void traverseInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700856
chaviw4b129c22018-04-09 16:19:43 -0700857 /**
858 * Traverse only children in z order, ignoring relative layers that are not children of the
859 * parent.
860 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200861 void traverseChildrenInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
chaviwa76b2712017-09-20 12:02:26 -0700862
Chia-I Wu98f1c102017-05-30 14:54:08 -0700863 size_t getChildrenCount() const;
Valerie Hauc5686802019-11-22 14:18:09 -0800864
865 // ONLY CALL THIS FROM THE LAYER DTOR!
866 // See b/141111965. We need to add current children to offscreen layers in
867 // the layer dtor so as not to dangle layers. Since the layer has not
868 // committed its transaction when the layer is destroyed, we must add
869 // current children. This is safe in the dtor as we will no longer update
870 // the current state, but should not be called anywhere else!
871 LayerVector& getCurrentChildren() { return mCurrentChildren; }
872
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200873 void addChild(const sp<Layer>&);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700874 // Returns index if removed, or negative value otherwise
875 // for symmetry with Vector::remove
876 ssize_t removeChild(const sp<Layer>& layer);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700877 sp<Layer> getParent() const { return mCurrentParent.promote(); }
Robert Carr1f0a16a2016-10-24 16:27:39 -0700878 bool hasParent() const { return getParent() != nullptr; }
Vishnu Nair4351ad52019-02-11 14:13:02 -0800879 Rect getScreenBounds(bool reduceTransparentRegion = true) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700880 bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
Robert Carr503c7042017-09-27 15:06:08 -0700881 bool setChildRelativeLayer(const sp<Layer>& childLayer,
882 const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700883
884 // Copy the current list of children to the drawing state. Called by
885 // SurfaceFlinger to complete a transaction.
886 void commitChildList();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200887 int32_t getZ(LayerVector::StateSet) const;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800888
Vishnu Nairefc42e22019-12-03 17:36:12 -0800889 /**
890 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
891 * INVALID_RECT if the layer has no buffer and no crop.
892 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer
893 * bounds are constrained by its parent bounds.
894 */
895 Rect getCroppedBufferSize(const Layer::State& s) const;
896
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200897 bool setFrameRate(FrameRate);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700898
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000899 virtual void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& /*info*/) {}
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000900 void setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info, nsecs_t postTime);
901 void setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info,
902 nsecs_t postTime);
903
904 void addSurfaceFrameDroppedForBuffer(
905 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
906 void addSurfaceFramePresentedForBuffer(
907 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime,
908 nsecs_t currentLatchTime);
909
910 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForTransaction(
911 const FrameTimelineInfo& info, nsecs_t postTime);
912 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForBuffer(
913 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName);
Ady Abraham74e17562020-08-24 18:18:19 -0700914
Peiyong Linf243e5e2020-08-22 17:40:59 -0700915 // Creates a new handle each time, so we only expect
916 // this to be called once.
917 sp<IBinder> getHandle();
918 const std::string& getName() const { return mName; }
919 bool getPremultipledAlpha() const;
920 void setInputInfo(const InputWindowInfo& info);
921
[1;3C2b9fc252021-02-04 16:16:50 -0800922 InputWindowInfo fillInputInfo(const sp<DisplayDevice>& display);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700923 /**
924 * Returns whether this layer has an explicitly set input-info.
925 */
926 bool hasInputInfo() const;
927
Ady Abraham62a0be22020-12-08 16:54:10 -0800928 virtual uid_t getOwnerUid() const { return mOwnerUid; }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700929
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700930 pid_t getOwnerPid() { return mOwnerPid; }
931
Peiyong Linf243e5e2020-08-22 17:40:59 -0700932 // This layer is not a clone, but it's the parent to the cloned hierarchy. The
933 // variable mClonedChild represents the top layer that will be cloned so this
934 // layer will be the parent of mClonedChild.
935 // The layers in the cloned hierarchy will match the lifetime of the real layers. That is
936 // if the real layer is destroyed, then the clone layer will also be destroyed.
937 sp<Layer> mClonedChild;
938
939 mutable bool contentDirty{false};
940 Region surfaceDamageRegion;
941
942 // Layer serial number. This gives layers an explicit ordering, so we
943 // have a stable sort order when their layer stack and Z-order are
944 // the same.
945 int32_t sequence{sSequence++};
946
947 bool mPendingHWCDestroy{false};
Steven Thomas3172e202020-01-06 19:25:30 -0800948
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800949 bool backpressureEnabled() { return mDrawingState.flags & layer_state_t::eEnableBackpressure; }
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800950
John Reckcdb4ed72021-02-04 13:39:33 -0500951 bool setStretchEffect(const StretchEffect& effect);
John Reckc00c6692021-02-16 11:37:33 -0500952 StretchEffect getStretchEffect() const;
John Reckcdb4ed72021-02-04 13:39:33 -0500953
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800954 virtual std::atomic<int32_t>* getPendingBufferCounter() { return nullptr; }
955 virtual std::string getPendingBufferCounterName() { return ""; }
956
Mathias Agopian13127d82013-03-05 17:47:11 -0800957protected:
David Sodman41fdfc92017-11-06 16:09:56 -0800958 class SyncPoint {
Dan Stoza7dde5992015-05-22 09:51:44 -0700959 public:
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800960 explicit SyncPoint(uint64_t frameNumber, wp<Layer> requestedSyncLayer,
961 wp<Layer> barrierLayer_legacy)
chaviw43cb3cb2019-05-31 15:23:41 -0700962 : mFrameNumber(frameNumber),
963 mFrameIsAvailable(false),
964 mTransactionIsApplied(false),
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800965 mRequestedSyncLayer(requestedSyncLayer),
966 mBarrierLayer_legacy(barrierLayer_legacy) {}
David Sodman41fdfc92017-11-06 16:09:56 -0800967 uint64_t getFrameNumber() const { return mFrameNumber; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700968
David Sodman41fdfc92017-11-06 16:09:56 -0800969 bool frameIsAvailable() const { return mFrameIsAvailable; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700970
David Sodman41fdfc92017-11-06 16:09:56 -0800971 void setFrameAvailable() { mFrameIsAvailable = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700972
David Sodman41fdfc92017-11-06 16:09:56 -0800973 bool transactionIsApplied() const { return mTransactionIsApplied; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700974
David Sodman41fdfc92017-11-06 16:09:56 -0800975 void setTransactionApplied() { mTransactionIsApplied = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700976
chaviw43cb3cb2019-05-31 15:23:41 -0700977 sp<Layer> getRequestedSyncLayer() { return mRequestedSyncLayer.promote(); }
978
KaiChieh Chuang948c6422020-10-13 10:38:48 +0800979 sp<Layer> getBarrierLayer() const { return mBarrierLayer_legacy.promote(); }
980
981 bool isTimeout() const {
982 using namespace std::chrono_literals;
983 static constexpr std::chrono::nanoseconds TIMEOUT_THRESHOLD = 1s;
984
985 return std::chrono::steady_clock::now() - mCreateTimeStamp > TIMEOUT_THRESHOLD;
986 }
987
988 void checkTimeoutAndLog() {
989 using namespace std::chrono_literals;
990 static constexpr std::chrono::nanoseconds LOG_PERIOD = 1s;
991
992 if (!frameIsAvailable() && isTimeout()) {
993 const auto now = std::chrono::steady_clock::now();
994 if (now - mLastLogTime > LOG_PERIOD) {
995 mLastLogTime = now;
996 sp<Layer> requestedSyncLayer = getRequestedSyncLayer();
997 sp<Layer> barrierLayer = getBarrierLayer();
998 ALOGW("[%s] sync point %" PRIu64 " wait timeout %lld for %s",
999 requestedSyncLayer ? requestedSyncLayer->getDebugName() : "Removed",
1000 mFrameNumber, (now - mCreateTimeStamp).count(),
1001 barrierLayer ? barrierLayer->getDebugName() : "Removed");
1002 }
1003 }
1004 }
1005
Dan Stoza7dde5992015-05-22 09:51:44 -07001006 private:
1007 const uint64_t mFrameNumber;
1008 std::atomic<bool> mFrameIsAvailable;
1009 std::atomic<bool> mTransactionIsApplied;
chaviw43cb3cb2019-05-31 15:23:41 -07001010 wp<Layer> mRequestedSyncLayer;
KaiChieh Chuang948c6422020-10-13 10:38:48 +08001011 wp<Layer> mBarrierLayer_legacy;
1012 const std::chrono::time_point<std::chrono::steady_clock> mCreateTimeStamp =
1013 std::chrono::steady_clock::now();
1014 std::chrono::time_point<std::chrono::steady_clock> mLastLogTime;
Dan Stoza7dde5992015-05-22 09:51:44 -07001015 };
1016
Peiyong Linf243e5e2020-08-22 17:40:59 -07001017 friend class impl::SurfaceInterceptor;
1018
1019 // For unit tests
1020 friend class TestableSurfaceFlinger;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001021 friend class FpsReporterTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -07001022 friend class RefreshRateSelectionTest;
1023 friend class SetFrameRateTest;
Adithya Srinivasanb238cd52021-02-04 17:54:05 +00001024 friend class TransactionFrameTracerTest;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001025 friend class TransactionSurfaceFrameTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -07001026
1027 virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
1028 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition(
1029 compositionengine::LayerFE::ClientCompositionTargetSettings&);
1030 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareShadowClientComposition(
1031 const LayerFE::LayerSettings&, const Rect& layerStackRect,
1032 ui::Dataspace outputDataspace);
1033 virtual void preparePerFrameCompositionState();
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001034 virtual void commitTransaction(State& stateToCommit);
Peiyong Linf243e5e2020-08-22 17:40:59 -07001035 virtual bool applyPendingStates(State* stateToCommit);
1036 virtual uint32_t doTransactionResize(uint32_t flags, Layer::State* stateToCommit);
Jorim Jaggi9c03b502020-11-24 23:51:31 +01001037 virtual void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&) {}
Peiyong Linf243e5e2020-08-22 17:40:59 -07001038
1039 // Returns mCurrentScaling mode (originating from the
1040 // Client) or mOverrideScalingMode mode (originating from
1041 // the Surface Controller) if set.
1042 virtual uint32_t getEffectiveScalingMode() const { return 0; }
1043
1044 sp<compositionengine::LayerFE> asLayerFE() const;
1045 sp<Layer> getClonedFrom() { return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr; }
1046 bool isClone() { return mClonedFrom != nullptr; }
1047 bool isClonedFromAlive() { return getClonedFrom() != nullptr; }
1048
1049 void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
1050 void updateClonedChildren(const sp<Layer>& mirrorRoot,
1051 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
1052 void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
1053 void addChildToDrawing(const sp<Layer>&);
1054 void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
1055
1056 // Modifies the passed in layer settings to clear the contents. If the blackout flag is set,
1057 // the settings clears the content with a solid black fill.
1058 void prepareClearClientComposition(LayerFE::LayerSettings&, bool blackout) const;
1059
1060 void prepareBasicGeometryCompositionState();
1061 void prepareGeometryCompositionState();
1062 void prepareCursorCompositionState();
1063
1064 uint32_t getEffectiveUsage(uint32_t usage) const;
1065
1066 /**
1067 * Setup rounded corners coordinates of this layer, taking into account the layer bounds and
1068 * crop coordinates, transforming them into layer space.
1069 */
1070 void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const;
1071 void setParent(const sp<Layer>&);
1072 LayerVector makeTraversalList(LayerVector::StateSet, bool* outSkipRelativeZUsers);
1073 void addZOrderRelative(const wp<Layer>& relative);
1074 void removeZOrderRelative(const wp<Layer>& relative);
1075 compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const;
1076 bool usingRelativeZ(LayerVector::StateSet) const;
1077
Dan Stozacac35382016-01-27 12:21:06 -08001078 // SyncPoints which will be signaled when the correct frame is at the head
1079 // of the queue and dropped after the frame has been latched. Protected by
1080 // mLocalSyncPointMutex.
1081 Mutex mLocalSyncPointMutex;
Dan Stoza7dde5992015-05-22 09:51:44 -07001082 std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
1083
Dan Stozacac35382016-01-27 12:21:06 -08001084 // SyncPoints which will be signaled and then dropped when the transaction
1085 // is applied
Dan Stoza7dde5992015-05-22 09:51:44 -07001086 std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
1087
Dan Stozacac35382016-01-27 12:21:06 -08001088 // Returns false if the relevant frame has already been latched
1089 bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
Dan Stoza7dde5992015-05-22 09:51:44 -07001090
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001091 void popPendingState(State* stateToCommit);
Robert Carrc3574f72016-03-24 12:19:32 -07001092
Peiyong Linf243e5e2020-08-22 17:40:59 -07001093 // constant
1094 sp<SurfaceFlinger> mFlinger;
Mathias Agopianb7e930d2010-06-01 15:12:58 -07001095
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001096 bool mPremultipliedAlpha{true};
Dominik Laskowski87a07e42019-10-10 20:38:02 -07001097 const std::string mName;
1098 const std::string mTransactionName{"TX - " + mName};
Mathias Agopian13127d82013-03-05 17:47:11 -08001099
Vishnu Nair8406fd72019-07-30 11:29:31 -07001100 // These are only accessed by the main thread or the tracing thread.
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001101 State mDrawingState;
Vishnu Nair8406fd72019-07-30 11:29:31 -07001102 // Store a copy of the pending state so that the drawing thread can access the
1103 // states without a lock.
KaiChieh Chuang948c6422020-10-13 10:38:48 +08001104 std::deque<State> mPendingStatesSnapshot;
Lloyd Pique0449b0f2018-12-20 16:23:45 -08001105
Vishnu Nair8406fd72019-07-30 11:29:31 -07001106 // these are protected by an external lock (mStateLock)
1107 State mCurrentState;
1108 std::atomic<uint32_t> mTransactionFlags{0};
KaiChieh Chuang948c6422020-10-13 10:38:48 +08001109 std::deque<State> mPendingStates;
Dan Stoza7dde5992015-05-22 09:51:44 -07001110
Brian Andersond6927fb2016-07-23 23:37:30 -07001111 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001112 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -07001113
Brian Andersond6927fb2016-07-23 23:37:30 -07001114 // Timestamp history for the consumer to query.
1115 // Accessed by both consumer and producer on main and binder threads.
1116 Mutex mFrameEventHistoryMutex;
Brian Anderson3890c392016-07-25 12:48:08 -07001117 ConsumerFrameEventHistory mFrameEventHistory;
Brian Anderson3d4039d2016-09-23 16:31:30 -07001118 FenceTimeline mAcquireTimeline;
1119 FenceTimeline mReleaseTimeline;
Brian Andersond6927fb2016-07-23 23:37:30 -07001120
Mathias Agopiana67932f2011-04-20 14:20:59 -07001121 // main thread
Lloyd Pique0b785d82018-12-04 17:25:27 -08001122 sp<NativeHandle> mSidebandStream;
Alec Mourie7d1d4a2019-02-05 01:13:46 +00001123 // False if the buffer and its contents have been previously used for GPU
1124 // composition, true otherwise.
1125 bool mIsActiveBufferUpdatedForGpu = true;
1126
Robert Carrc3574f72016-03-24 12:19:32 -07001127 // We encode unset as -1.
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001128 std::atomic<uint64_t> mCurrentFrameNumber{0};
Mathias Agopian13127d82013-03-05 17:47:11 -08001129 // Whether filtering is needed b/c of the drawingstate
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001130 bool mNeedsFiltering{false};
David Sodman0c69cad2017-08-21 12:12:51 -07001131
Robert Carr2e102c92018-10-23 12:11:15 -07001132 std::atomic<bool> mRemovedFromCurrentState{false};
chaviw8b3871a2017-11-01 17:41:01 -07001133
Mathias Agopianb7e930d2010-06-01 15:12:58 -07001134 // page-flip thread (currently main thread)
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001135 bool mProtectedByApp{false}; // application requires protected path to external sink
Mathias Agopian13127d82013-03-05 17:47:11 -08001136
1137 // protected by mLock
1138 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -07001139
Mathias Agopian13127d82013-03-05 17:47:11 -08001140 const wp<Client> mClientRef;
Riley Andrews03414a12014-07-01 14:22:59 -07001141
1142 // This layer can be a cursor on some displays.
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001143 bool mPotentialCursor{false};
Dan Stoza6b9454d2014-11-07 16:00:59 -08001144
Robert Carr1f0a16a2016-10-24 16:27:39 -07001145 // Child list about to be committed/used for editing.
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001146 LayerVector mCurrentChildren{LayerVector::StateSet::Current};
Robert Carr1f0a16a2016-10-24 16:27:39 -07001147 // Child list used for rendering.
Lloyd Pique42ab75e2018-09-12 20:46:03 -07001148 LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};
Robert Carr1f0a16a2016-10-24 16:27:39 -07001149
Chia-I Wue41dbe62017-06-13 14:10:56 -07001150 wp<Layer> mCurrentParent;
1151 wp<Layer> mDrawingParent;
David Sodman9eeae692017-11-02 10:53:32 -07001152
chaviw5aedec92018-10-22 10:40:38 -07001153 // Can only be accessed with the SF state lock held.
Robert Carr1323c952019-01-28 18:13:27 -08001154 bool mChildrenChanged{false};
chaviw5aedec92018-10-22 10:40:38 -07001155
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001156 // Window types from WindowManager.LayoutParams
Michael Wright44753b12020-07-08 13:48:11 +01001157 const InputWindowInfo::Type mWindowType;
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001158
Alec Mouri9a29e672020-09-14 12:39:14 -07001159 // The owner of the layer. If created from a non system process, it will be the calling uid.
1160 // If created from a system process, the value can be passed in.
1161 uid_t mOwnerUid;
1162
Adithya Srinivasan9febda82020-10-19 10:49:41 -07001163 // The owner pid of the layer. If created from a non system process, it will be the calling pid.
1164 // If created from a system process, the value can be passed in.
1165 pid_t mOwnerPid;
1166
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001167 // Keeps track of the time SF latched the last buffer from this layer.
1168 // Used in buffer stuffing analysis in FrameTimeline.
1169 nsecs_t mLastLatchTime = 0;
1170
chaviw4b129c22018-04-09 16:19:43 -07001171private:
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001172 virtual void setTransformHint(ui::Transform::RotationFlags) {}
1173
Peiyong Linf243e5e2020-08-22 17:40:59 -07001174 // Returns true if the layer can draw shadows on its border.
1175 virtual bool canDrawShadows() const { return true; }
1176
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001177 Hwc2::IComposerClient::Composition getCompositionType(const DisplayDevice&) const;
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001178
chaviw4b129c22018-04-09 16:19:43 -07001179 /**
1180 * Returns an unsorted vector of all layers that are part of this tree.
1181 * That includes the current layer and all its descendants.
1182 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02001183 std::vector<Layer*> getLayersInTree(LayerVector::StateSet);
chaviw4b129c22018-04-09 16:19:43 -07001184 /**
1185 * Traverses layers that are part of this tree in the correct z order.
1186 * layersInTree must be sorted before calling this method.
1187 */
1188 void traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02001189 LayerVector::StateSet, const LayerVector::Visitor&);
1190 LayerVector makeChildrenTraversalList(LayerVector::StateSet,
chaviw4b129c22018-04-09 16:19:43 -07001191 const std::vector<Layer*>& layersInTree);
Vishnu Nair4351ad52019-02-11 14:13:02 -08001192
Ady Abraham60e42ea2020-03-09 19:17:31 -07001193 void updateTreeHasFrameRateVote();
Peiyong Linf243e5e2020-08-22 17:40:59 -07001194 void setZOrderRelativeOf(const wp<Layer>& relativeOf);
1195 void removeRemoteSyncPoints();
1196
1197 // Find the root of the cloned hierarchy, this means the first non cloned parent.
1198 // This will return null if first non cloned parent is not found.
1199 sp<Layer> getClonedRoot();
1200
1201 // Finds the top most layer in the hierarchy. This will find the root Layer where the parent is
1202 // null.
1203 sp<Layer> getRootLayer();
Ady Abraham60e42ea2020-03-09 19:17:31 -07001204
chaviw7e72caf2020-12-02 16:50:43 -08001205 // Fills in the frame and transform info for the InputWindowInfo
[1;3C2b9fc252021-02-04 16:16:50 -08001206 void fillInputFrameInfo(InputWindowInfo& info, const ui::Transform& toPhysicalDisplay);
chaviw7e72caf2020-12-02 16:50:43 -08001207
Vishnu Nair4351ad52019-02-11 14:13:02 -08001208 // Cached properties computed from drawing state
Peiyong Lin74861ad2020-10-14 11:55:33 -07001209 // Effective transform taking into account parent transforms and any parent scaling, which is
1210 // a transform from the current layer coordinate space to display(screen) coordinate space.
Vishnu Nair4351ad52019-02-11 14:13:02 -08001211 ui::Transform mEffectiveTransform;
1212
1213 // Bounds of the layer before any transformation is applied and before it has been cropped
1214 // by its parents.
1215 FloatRect mSourceBounds;
1216
1217 // Bounds of the layer in layer space. This is the mSourceBounds cropped by its layer crop and
1218 // its parent bounds.
1219 FloatRect mBounds;
1220
1221 // Layer bounds in screen space.
1222 FloatRect mScreenBounds;
chaviw606e5cf2019-03-01 10:12:10 -08001223
Robert Carrc0df3122019-04-11 13:18:21 -07001224 bool mGetHandleCalled = false;
chaviw43cb3cb2019-05-31 15:23:41 -07001225
Vishnu Nair0f085c62019-08-30 08:49:12 -07001226 // Tracks the process and user id of the caller when creating this layer
1227 // to help debugging.
1228 pid_t mCallingPid;
1229 uid_t mCallingUid;
chaviwb4c6e582019-08-16 14:35:07 -07001230
1231 // The current layer is a clone of mClonedFrom. This means that this layer will update it's
1232 // properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers,
1233 // this layer will update it's buffer. When mClonedFrom updates it's drawing state, children,
1234 // and relatives, this layer will update as well.
1235 wp<Layer> mClonedFrom;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001236
1237 // The inherited shadow radius after taking into account the layer hierarchy. This is the
1238 // final shadow radius for this layer. If a shadow is specified for a layer, then effective
1239 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius.
Vishnu Nairf37dcfb2019-11-16 07:37:09 -08001240 float mEffectiveShadowRadius = 0.f;
Lucas Dupinc3800b82020-10-02 16:24:48 -07001241
1242 // A list of regions on this layer that should have blurs.
1243 const std::vector<BlurRegion>& getBlurRegions() const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001244};
1245
Marin Shalamanov46084422020-10-13 12:33:42 +02001246std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate);
1247
Dominik Laskowski34157762018-10-31 13:07:19 -07001248} // namespace android