blob: 0bfab7cc77560a60e177381753cb9af82e29f704 [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
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -070019#include <android/gui/DropInputMode.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080020#include <android/gui/ISurfaceComposerClient.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070021#include <gui/BufferQueue.h>
Peiyong Lincbc184f2018-08-22 13:24:10 -070022#include <gui/LayerState.h>
chaviw98318de2021-05-19 16:45:23 -050023#include <gui/WindowInfo.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
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080040#include <compositionengine/LayerFE.h>
Vishnu Nairbedb44b2022-08-02 21:47:40 +000041#include <compositionengine/LayerFECompositionState.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080042#include <scheduler/Fps.h>
43#include <scheduler/Seamlessness.h>
44
KaiChieh Chuang948c6422020-10-13 10:38:48 +080045#include <chrono>
Robert Carrcdf83202018-03-07 12:48:34 -080046#include <cstdint>
Peiyong Lincbc184f2018-08-22 13:24:10 -070047#include <list>
Dominik Laskowski075d3172018-05-24 15:50:06 -070048#include <optional>
Peiyong Lincbc184f2018-08-22 13:24:10 -070049#include <vector>
Dan Stoza7dde5992015-05-22 09:51:44 -070050
Mathias Agopian13127d82013-03-05 17:47:11 -080051#include "Client.h"
Alec Mouri1c8d7202019-06-01 18:51:35 -070052#include "DisplayHardware/HWComposer.h"
David Sodman41fdfc92017-11-06 16:09:56 -080053#include "FrameTracker.h"
Vishnu Naire14c6b32022-08-06 04:20:15 +000054#include "LayerFE.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070055#include "LayerVector.h"
Ady Abrahambdda8f02021-04-01 16:06:11 -070056#include "Scheduler/LayerInfo.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080057#include "SurfaceFlinger.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070058#include "Tracing/LayerTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080059#include "TransactionCallbackInvoker.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080060
chaviw1d044282017-09-27 12:19:28 -070061using namespace android::surfaceflinger;
62
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080063namespace android {
64
Mathias Agopian1f7bec62010-06-25 18:02:21 -070065class Client;
Mathias Agopian3e25fd82013-04-22 17:52:16 +020066class Colorizer;
Mathias Agopian13127d82013-03-05 17:47:11 -080067class DisplayDevice;
68class GraphicBuffer;
69class SurfaceFlinger;
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
Huihong Luo05539a12022-02-23 10:29:40 -080076namespace gui {
77class LayerDebugInfo;
78}
79
Ady Abraham22c7b5c2020-09-22 19:33:40 -070080namespace frametimeline {
81class SurfaceFrame;
82} // namespace frametimeline
83
Vishnu Naire14c6b32022-08-06 04:20:15 +000084class Layer : public virtual RefBase {
Vishnu Nairdc4d31b2022-11-17 03:20:58 +000085public:
Ady Abrahamaae5ed52020-06-26 09:32:43 -070086 // The following constants represent priority of the window. SF uses this information when
87 // deciding which window has a priority when deciding about the refresh rate of the screen.
88 // Priority 0 is considered the highest priority. -1 means that the priority is unset.
Ana Krulecc84d09b2019-11-02 23:10:29 +010089 static constexpr int32_t PRIORITY_UNSET = -1;
Ady Abrahamaae5ed52020-06-26 09:32:43 -070090 // Windows that are in focus and voted for the preferred mode ID
91 static constexpr int32_t PRIORITY_FOCUSED_WITH_MODE = 0;
92 // // Windows that are in focus, but have not requested a specific mode ID.
93 static constexpr int32_t PRIORITY_FOCUSED_WITHOUT_MODE = 1;
94 // Windows that are not in focus, but voted for a specific mode ID.
95 static constexpr int32_t PRIORITY_NOT_FOCUSED_WITH_MODE = 2;
Mathias Agopian13127d82013-03-05 17:47:11 -080096
Mathias Agopian13127d82013-03-05 17:47:11 -080097 enum { // flags for doTransaction()
98 eDontUpdateGeometryState = 0x00000001,
99 eVisibleRegion = 0x00000002,
Robert Carr720e5062018-07-30 17:45:14 -0700100 eInputInfoChanged = 0x00000004
Mathias Agopian13127d82013-03-05 17:47:11 -0800101 };
102
103 struct Geometry {
104 uint32_t w;
105 uint32_t h;
Peiyong Linefefaac2018-08-17 12:27:51 -0700106 ui::Transform transform;
Robert Carr3dcabfa2016-03-01 18:36:58 -0800107
David Sodman41fdfc92017-11-06 16:09:56 -0800108 inline bool operator==(const Geometry& rhs) const {
109 return (w == rhs.w && h == rhs.h) && (transform.tx() == rhs.transform.tx()) &&
Robert Carr99e27f02016-06-16 15:18:02 -0700110 (transform.ty() == rhs.transform.ty());
Mathias Agopian13127d82013-03-05 17:47:11 -0800111 }
David Sodman41fdfc92017-11-06 16:09:56 -0800112 inline bool operator!=(const Geometry& rhs) const { return !operator==(rhs); }
Mathias Agopian13127d82013-03-05 17:47:11 -0800113 };
114
Ady Abrahambdda8f02021-04-01 16:06:11 -0700115 using FrameRate = scheduler::LayerInfo::FrameRate;
116 using FrameRateCompatibility = scheduler::LayerInfo::FrameRateCompatibility;
Ady Abraham71c437d2020-01-31 15:56:57 -0800117
Mathias Agopian13127d82013-03-05 17:47:11 -0800118 struct State {
Robert Carrae060832016-11-28 10:51:00 -0800119 int32_t z;
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700120 ui::LayerStack layerStack;
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800121 uint32_t flags;
Mathias Agopian13127d82013-03-05 17:47:11 -0800122 int32_t sequence; // changes when visible regions can change
Dan Stoza7dde5992015-05-22 09:51:44 -0700123 bool modified;
Fabien Sanglard4ed383c2016-12-13 14:02:41 -0800124 // Crop is expressed in layer space coordinate.
chaviw25714502021-02-11 10:01:08 -0800125 Rect crop;
Evan Rosky1f6d6d52018-12-06 10:47:26 -0800126 LayerMetadata metadata;
Robert Carrdb66e622017-04-10 16:55:57 -0700127 // If non-null, a Surface this Surface's Z-order is interpreted relative to.
128 wp<Layer> zOrderRelativeOf;
chaviwe5ac40f2019-09-24 16:36:55 -0700129 bool isRelativeOf{false};
Robert Carrdb66e622017-04-10 16:55:57 -0700130
131 // A list of surfaces whose Z-order is interpreted relative to ours.
132 SortedVector<wp<Layer>> zOrderRelatives;
chaviw13fdc492017-06-27 12:40:18 -0700133 half4 color;
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700134 float cornerRadius;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800135 int backgroundBlurRadius;
chaviw98318de2021-05-19 16:45:23 -0500136 gui::WindowInfo inputInfo;
Vishnu Nair6fabeec2019-03-12 13:42:49 -0700137 wp<Layer> touchableRegionCrop;
Robert Carr720e5062018-07-30 17:45:14 -0700138
Valerie Haub153bab2019-03-05 10:47:28 -0800139 ui::Dataspace dataspace;
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +0000140 bool dataspaceRequested;
Valerie Haub153bab2019-03-05 10:47:28 -0800141
Valerie Hau134651a2020-01-28 16:21:22 -0800142 uint64_t frameNumber;
chaviw766c9c52021-02-10 17:36:47 -0800143 ui::Transform transform;
liulijuneb489f62022-10-17 22:02:14 +0800144
145 uint32_t producerId = 0;
chaviw766c9c52021-02-10 17:36:47 -0800146 uint32_t bufferTransform;
Marissa Wall61c58622018-07-18 10:12:20 -0700147 bool transformToDisplayInverse;
Marissa Wall61c58622018-07-18 10:12:20 -0700148 Region transparentRegionHint;
Alec Mouria90a5702021-04-16 16:36:21 +0000149 std::shared_ptr<renderengine::ExternalTexture> buffer;
Marissa Wall947d34e2019-03-29 14:03:53 -0700150 client_cache_t clientCacheId;
Marissa Wall61c58622018-07-18 10:12:20 -0700151 sp<Fence> acquireFence;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700152 std::shared_ptr<FenceTime> acquireFenceTime;
Marissa Wall61c58622018-07-18 10:12:20 -0700153 HdrMetadata hdrMetadata;
154 Region surfaceDamageRegion;
155 int32_t api;
Marissa Wall61c58622018-07-18 10:12:20 -0700156 sp<NativeHandle> sidebandStream;
Peiyong Lind3788632018-09-18 16:01:31 -0700157 mat4 colorTransform;
Peiyong Lin747321c2018-10-01 10:03:11 -0700158 bool hasColorTransform;
Valerie Haua72e2812019-01-23 13:40:39 -0800159 // pointer to background color layer that, if set, appears below the buffer state layer
160 // and the buffer state layer's children. Z order will be set to
161 // INT_MIN
162 sp<Layer> bgColorLayer;
Valerie Haued54efa2019-01-11 20:03:14 -0800163
Marissa Walle2ffb422018-10-12 11:33:52 -0700164 // The deque of callback handles for this frame. The back of the deque contains the most
165 // recent callback handle.
166 std::deque<sp<CallbackHandle>> callbackHandles;
Peiyong Linc502cb72019-03-01 15:00:23 -0800167 bool colorSpaceAgnostic;
Ady Abrahamf0c56492020-12-17 18:04:15 -0800168 nsecs_t desiredPresentTime = 0;
169 bool isAutoTimestamp = true;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800170
171 // Length of the cast shadow. If the radius is > 0, a shadow of length shadowRadius will
172 // be rendered around the layer.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700173 float shadowRadius;
Ana Krulecc84d09b2019-11-02 23:10:29 +0100174
Lucas Dupinc3800b82020-10-02 16:24:48 -0700175 // Layer regions that are made of custom materials, like frosted glass
176 std::vector<BlurRegion> blurRegions;
177
Ana Krulecc84d09b2019-11-02 23:10:29 +0100178 // Priority of the layer assigned by Window Manager.
179 int32_t frameRateSelectionPriority;
Steven Thomas3172e202020-01-06 19:25:30 -0800180
Andy Labrada096227e2022-06-15 16:58:11 +0000181 // Default frame rate compatibility used to set the layer refresh rate votetype.
182 FrameRateCompatibility defaultFrameRateCompatibility;
Ady Abraham71c437d2020-01-31 15:56:57 -0800183 FrameRate frameRate;
Ady Abraham60e42ea2020-03-09 19:17:31 -0700184
Ady Abraham59fd8ff2021-04-15 20:13:30 -0700185 // The combined frame rate of parents / children of this layer
186 FrameRate frameRateForLayerTree;
Vishnu Nair6213bd92020-05-08 17:42:25 -0700187
188 // Set by window manager indicating the layer and all its children are
189 // in a different orientation than the display. The hint suggests that
190 // the graphic producers should receive a transform hint as if the
191 // display was in this orientation. When the display changes to match
192 // the layer orientation, the graphic producer may not need to allocate
193 // a buffer of a different size. ui::Transform::ROT_INVALID means the
194 // a fixed transform hint is not set.
195 ui::Transform::RotationFlags fixedTransformHint;
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700196
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000197 // The vsync info that was used to start the transaction
198 FrameTimelineInfo frameTimelineInfo;
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700199
200 // When the transaction was posted
201 nsecs_t postTime;
Vishnu Nair1506b182021-02-22 14:35:15 -0800202 sp<ITransactionCompletedListener> releaseBufferListener;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000203 // SurfaceFrame that tracks the timeline of Transactions that contain a Buffer. Only one
204 // such SurfaceFrame exists because only one buffer can be presented on the layer per vsync.
205 // If multiple buffers are queued, the prior ones will be dropped, along with the
206 // SurfaceFrame that's tracking them.
207 std::shared_ptr<frametimeline::SurfaceFrame> bufferSurfaceFrameTX;
208 // A map of token(frametimelineVsyncId) to the SurfaceFrame that's tracking a transaction
209 // that contains the token. Only one SurfaceFrame exisits for transactions that share the
210 // same token, unless they are presented in different vsyncs.
211 std::unordered_map<int64_t, std::shared_ptr<frametimeline::SurfaceFrame>>
212 bufferlessSurfaceFramesTX;
213 // An arbitrary threshold for the number of BufferlessSurfaceFrames in the state. Used to
214 // trigger a warning if the number of SurfaceFrames crosses the threshold.
215 static constexpr uint32_t kStateSurfaceFramesThreshold = 25;
John Reckcdb4ed72021-02-04 13:39:33 -0500216
217 // Stretch effect to apply to this layer
218 StretchEffect stretchEffect;
chaviwf3f40fe2021-04-27 15:54:02 -0500219
Winson Chunga30f7c92021-06-29 15:42:56 -0700220 // Whether or not this layer is a trusted overlay for input
221 bool isTrustedOverlay;
chaviwf3f40fe2021-04-27 15:54:02 -0500222 Rect bufferCrop;
Vishnu Nair6bdec7d2021-05-10 15:01:13 -0700223 Rect destinationFrame;
chaviw0b06a8d2021-08-06 11:49:08 -0500224 sp<IBinder> releaseBufferEndpoint;
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -0700225 gui::DropInputMode dropInputMode;
Vishnu Nair86653e92021-11-03 17:19:36 -0700226 bool autoRefresh = false;
Sally Qi421ffb02022-03-21 19:41:33 -0700227 bool dimmingEnabled = true;
Sally Qi963049b2023-03-23 14:06:21 -0700228 float currentHdrSdrRatio = 1.f;
229 float desiredHdrSdrRatio = 1.f;
Alec Mourif4af03e2023-02-11 00:25:24 +0000230 gui::CachingHint cachingHint = gui::CachingHint::Enabled;
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000231 int64_t latchedVsyncId = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -0800232 };
233
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700234 explicit Layer(const LayerCreationArgs& args);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700235 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800236
Peiyong Linf243e5e2020-08-22 17:40:59 -0700237 static bool isLayerFocusedBasedOnPriority(int32_t priority);
238 static void miniDumpHeader(std::string& result);
Dominik Laskowski75848362019-11-11 17:57:20 -0800239
Peiyong Linf243e5e2020-08-22 17:40:59 -0700240 // Provide unique string for each class type in the Layer hierarchy
Patrick Williamsbb25f802022-08-30 23:02:34 +0000241 virtual const char* getType() const { return "Layer"; }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700242
Peiyong Linf243e5e2020-08-22 17:40:59 -0700243 // true if this layer is visible, false otherwise
Patrick Williamsbb25f802022-08-30 23:02:34 +0000244 virtual bool isVisible() const;
Chia-I Wuab0c3192017-08-01 11:29:00 -0700245
Patrick Williamsbb25f802022-08-30 23:02:34 +0000246 virtual sp<Layer> createClone();
Peiyong Linf243e5e2020-08-22 17:40:59 -0700247
Robert Carr7bf247e2017-05-18 14:02:49 -0700248 // Set a 2x2 transformation matrix on the layer. This transform
249 // will be applied after parent transforms, but before any final
250 // producer specified transform.
Patrick Williamsbb25f802022-08-30 23:02:34 +0000251 bool setMatrix(const layer_state_t::matrix22_t& matrix);
Robert Carr7bf247e2017-05-18 14:02:49 -0700252
253 // This second set of geometry attributes are controlled by
254 // setGeometryAppliesWithResize, and their default mode is to be
255 // immediate. If setGeometryAppliesWithResize is specified
256 // while a resize is pending, then update of these attributes will
257 // be delayed until the resize completes.
258
259 // setPosition operates in parent buffer space (pre parent-transform) or display
260 // space for top-level layers.
Patrick Williamsbb25f802022-08-30 23:02:34 +0000261 bool setPosition(float x, float y);
Robert Carr7bf247e2017-05-18 14:02:49 -0700262 // Buffer space
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +0000263 bool setCrop(const Rect& crop);
Robert Carr8d5227b2017-03-16 15:41:03 -0700264
Robert Carr7bf247e2017-05-18 14:02:49 -0700265 // TODO(b/38182121): Could we eliminate the various latching modes by
266 // using the layer hierarchy?
267 // -----------------------------------------------------------------------
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800268 virtual bool setLayer(int32_t z);
269 virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carrdb66e622017-04-10 16:55:57 -0700270
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800271 virtual bool setAlpha(float alpha);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000272 bool setColor(const half3& /*color*/);
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700273
274 // Set rounded corner radius for this layer and its children.
275 //
276 // We only support 1 radius per layer in the hierarchy, where parent layers have precedence.
277 // The shape of the rounded corner rectangle is specified by the crop rectangle of the layer
278 // from which we inferred the rounded corner radius.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800279 virtual bool setCornerRadius(float cornerRadius);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800280 // When non-zero, everything below this layer will be blurred by backgroundBlurRadius, which
281 // is specified in pixels.
282 virtual bool setBackgroundBlurRadius(int backgroundBlurRadius);
Lucas Dupinc3800b82020-10-02 16:24:48 -0700283 virtual bool setBlurRegions(const std::vector<BlurRegion>& effectRegions);
Vishnu Nairea04b6f2022-08-19 21:28:17 +0000284 bool setTransparentRegionHint(const Region& transparent);
Winson Chunga30f7c92021-06-29 15:42:56 -0700285 virtual bool setTrustedOverlay(bool);
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800286 virtual bool setFlags(uint32_t flags, uint32_t mask);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700287 virtual bool setLayerStack(ui::LayerStack);
Vishnu Nair73908d12022-10-24 21:46:42 -0700288 virtual ui::LayerStack getLayerStack(
289 LayerVector::StateSet state = LayerVector::StateSet::Drawing) const;
290
Evan Roskyef876c92019-01-25 17:46:06 -0800291 virtual bool setMetadata(const LayerMetadata& data);
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200292 virtual void setChildrenDrawingParent(const sp<Layer>&);
Josh Gao194ff392022-09-08 16:19:29 -0700293 virtual bool reparent(const sp<IBinder>& newParentHandle) REQUIRES(mFlinger->mStateLock);
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800294 virtual bool setColorTransform(const mat4& matrix);
295 virtual mat4 getColorTransform() const;
296 virtual bool hasColorTransform() const;
Peiyong Linc502cb72019-03-01 15:00:23 -0800297 virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; }
John Reck68796592023-01-25 13:47:12 -0500298 virtual bool isDimmingEnabled() const { return getDrawingState().dimmingEnabled; }
Sally Qi963049b2023-03-23 14:06:21 -0700299 float getDesiredHdrSdrRatio() const { return getDrawingState().desiredHdrSdrRatio; }
300 float getCurrentHdrSdrRatio() const { return getDrawingState().currentHdrSdrRatio; }
Alec Mourif4af03e2023-02-11 00:25:24 +0000301 gui::CachingHint getCachingHint() const { return getDrawingState().cachingHint; }
Marissa Wall61c58622018-07-18 10:12:20 -0700302
Patrick Williamsbb25f802022-08-30 23:02:34 +0000303 bool setTransform(uint32_t /*transform*/);
304 bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/);
305 bool setBuffer(std::shared_ptr<renderengine::ExternalTexture>& /* buffer */,
306 const BufferData& /* bufferData */, nsecs_t /* postTime */,
307 nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/,
Brian Lindahl439afad2022-11-14 11:16:55 -0700308 std::optional<nsecs_t> /* dequeueTime */, const FrameTimelineInfo& /*info*/);
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000309 void setDesiredPresentTime(nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000310 bool setDataspace(ui::Dataspace /*dataspace*/);
John Reck68796592023-01-25 13:47:12 -0500311 bool setExtendedRangeBrightness(float currentBufferRatio, float desiredRatio);
Alec Mourif4af03e2023-02-11 00:25:24 +0000312 bool setCachingHint(gui::CachingHint cachingHint);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000313 bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/);
314 bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/);
315 bool setApi(int32_t /*api*/);
316 bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000317 bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& /*handles*/,
318 bool willPresent);
Josh Gao194ff392022-09-08 16:19:29 -0700319 virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace)
320 REQUIRES(mFlinger->mStateLock);
Peiyong Linc502cb72019-03-01 15:00:23 -0800321 virtual bool setColorSpaceAgnostic(const bool agnostic);
Sally Qi421ffb02022-03-21 19:41:33 -0700322 virtual bool setDimmingEnabled(const bool dimmingEnabled);
Andy Labrada096227e2022-06-15 16:58:11 +0000323 virtual bool setDefaultFrameRateCompatibility(FrameRateCompatibility compatibility);
Ana Krulecc84d09b2019-11-02 23:10:29 +0100324 virtual bool setFrameRateSelectionPriority(int32_t priority);
Vishnu Nair6213bd92020-05-08 17:42:25 -0700325 virtual bool setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000326 void setAutoRefresh(bool /* autoRefresh */);
Vishnu Nair9cf4a4d2021-09-17 12:16:08 -0700327 bool setDropInputMode(gui::DropInputMode);
328
Ana Krulecc84d09b2019-11-02 23:10:29 +0100329 // If the variable is not set on the layer, it traverses up the tree to inherit the frame
330 // rate priority from its parent.
331 virtual int32_t getFrameRateSelectionPriority() const;
Andy Labrada096227e2022-06-15 16:58:11 +0000332 //
333 virtual FrameRateCompatibility getDefaultFrameRateCompatibility() const;
334 //
Patrick Williamsbb25f802022-08-30 23:02:34 +0000335 ui::Dataspace getDataSpace() const;
336 ui::Dataspace getRequestedDataSpace() const;
Chia-I Wu01591c92018-05-22 12:03:00 -0700337
Vishnu Naire14c6b32022-08-06 04:20:15 +0000338 virtual sp<LayerFE> getCompositionEngineLayerFE() const;
Patrick Williams7584c6a2022-10-29 02:10:58 +0000339 virtual sp<LayerFE> copyCompositionEngineLayerFE() const;
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000340 sp<LayerFE> getCompositionEngineLayerFE(const frontend::LayerHierarchy::TraversalPath&);
Vishnu Naire14c6b32022-08-06 04:20:15 +0000341
Vishnu Nair8fc721b2022-12-22 20:06:32 +0000342 const frontend::LayerSnapshot* getLayerSnapshot() const;
343 frontend::LayerSnapshot* editLayerSnapshot();
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000344 std::unique_ptr<frontend::LayerSnapshot> stealLayerSnapshot();
345 void updateLayerSnapshot(std::unique_ptr<frontend::LayerSnapshot> snapshot);
Lloyd Piquefeb73d72018-12-04 17:23:44 -0800346
Dan Stozaee44edd2015-03-23 15:50:23 -0700347 // If we have received a new buffer this frame, we will pass its surface
348 // damage down to hardware composer. Otherwise, we must send a region with
349 // one empty rect.
Patrick Williamsbb25f802022-08-30 23:02:34 +0000350 void useSurfaceDamage();
351 void useEmptyDamage();
Alec Mouriadebf5c2021-01-05 12:57:36 -0800352 Region getVisibleRegion(const DisplayDevice*) const;
Vishnu Naira156f482023-02-22 00:23:38 +0000353 void updateLastLatchTime(nsecs_t latchtime);
Dan Stozaee44edd2015-03-23 15:50:23 -0700354
Peiyong Linf243e5e2020-08-22 17:40:59 -0700355 /*
356 * isOpaque - true if this surface is opaque
357 *
358 * This takes into account the buffer format (i.e. whether or not the
359 * pixel format includes an alpha channel) and the "opaque" flag set
360 * on the layer. It does not examine the current plane alpha value.
361 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000362 bool isOpaque(const Layer::State&) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700363
364 /*
365 * Returns whether this layer can receive input.
366 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000367 bool canReceiveInput() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700368
369 /*
Peiyong Lin05cc0112020-10-14 16:16:37 -0700370 * isProtected - true if the layer may contain protected contents in the
Peiyong Linf243e5e2020-08-22 17:40:59 -0700371 * GRALLOC_USAGE_PROTECTED sense.
372 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000373 bool isProtected() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700374
375 /*
376 * isFixedSize - true if content has a fixed size
377 */
378 virtual bool isFixedSize() const { return true; }
379
380 /*
381 * usesSourceCrop - true if content should use a source crop
382 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000383 bool usesSourceCrop() const { return hasBufferOrSidebandStream(); }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700384
385 // Most layers aren't created from the main thread, and therefore need to
386 // grab the SF state lock to access HWC, but ContainerLayer does, so we need
387 // to avoid grabbing the lock again to avoid deadlock
388 virtual bool isCreatedFromMainThread() const { return false; }
389
chaviw4e765532021-04-30 12:11:39 -0500390 ui::Transform getActiveTransform(const Layer::State& s) const { return s.transform; }
Patrick Williamsbb25f802022-08-30 23:02:34 +0000391 Region getActiveTransparentRegion(const Layer::State& s) const {
392 return s.transparentRegionHint;
393 }
Vishnu Nairbc4ee5c2022-08-16 03:19:37 +0000394 Rect getCrop(const Layer::State& s) const { return s.crop; }
Patrick Williamsbb25f802022-08-30 23:02:34 +0000395 bool needsFiltering(const DisplayDevice*) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700396
397 // True if this layer requires filtering
398 // This method is distinct from needsFiltering() in how the filter
399 // requirement is computed. needsFiltering() compares displayFrame and crop,
400 // where as this method transforms the displayFrame to layer-stack space
401 // first. This method should be used if there is no physical display to
402 // project onto when taking screenshots, as the filtering requirements are
403 // different.
404 // If the parent transform needs to be undone when capturing the layer, then
405 // the inverse parent transform is also required.
Patrick Williamsbb25f802022-08-30 23:02:34 +0000406 bool needsFilteringForScreenshots(const DisplayDevice*, const ui::Transform&) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700407
Patrick Williamsbb25f802022-08-30 23:02:34 +0000408 // from graphics API
409 ui::Dataspace translateDataspace(ui::Dataspace dataspace);
410 void updateCloneBufferInfo();
411 uint64_t mPreviousFrameNumber = 0;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700412
Patrick Williamsbb25f802022-08-30 23:02:34 +0000413 bool isHdrY410() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700414
Peiyong Linf243e5e2020-08-22 17:40:59 -0700415 /*
416 * called after composition.
417 * returns true if the layer latched a new buffer this frame.
418 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000419 void onPostComposition(const DisplayDevice*, const std::shared_ptr<FenceTime>& /*glDoneFence*/,
420 const std::shared_ptr<FenceTime>& /*presentFence*/,
421 const CompositorTiming&);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700422
423 // If a buffer was replaced this frame, release the former buffer
Patrick Williamsbb25f802022-08-30 23:02:34 +0000424 void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700425
Peiyong Linf243e5e2020-08-22 17:40:59 -0700426 /*
427 * latchBuffer - called each time the screen is redrawn and returns whether
428 * the visible regions need to be recomputed (this is a fairly heavy
429 * operation, so this should be set only if needed). Typically this is used
430 * to figure out if the content or size of a surface has changed.
431 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000432 bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700433
Vishnu Naird47bcee2023-02-24 18:08:51 +0000434 bool latchBufferImpl(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
435 bool bgColorOnly);
436
Patrick Williamsbb25f802022-08-30 23:02:34 +0000437 /*
438 * Calls latchBuffer if the buffer has a frame queued and then releases the buffer.
439 * This is used if the buffer is just latched and releases to free up the buffer
440 * and will not be shown on screen.
441 * Should only be called on the main thread.
442 */
443 void latchAndReleaseBuffer();
Peiyong Linf243e5e2020-08-22 17:40:59 -0700444
445 /*
446 * returns the rectangle that crops the content of the layer and scales it
447 * to the layer's size.
448 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000449 Rect getBufferCrop() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700450
451 /*
452 * Returns the transform applied to the buffer.
453 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000454 uint32_t getBufferTransform() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700455
Patrick Williamsbb25f802022-08-30 23:02:34 +0000456 sp<GraphicBuffer> getBuffer() const;
457 const std::shared_ptr<renderengine::ExternalTexture>& getExternalTexture() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700458
Peiyong Linf243e5e2020-08-22 17:40:59 -0700459 /*
460 * Returns if a frame is ready
461 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000462 bool hasReadyFrame() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700463
464 virtual int32_t getQueuedFrameCount() const { return 0; }
465
Peiyong Linf243e5e2020-08-22 17:40:59 -0700466 /**
467 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing
Patrick Williamsbb25f802022-08-30 23:02:34 +0000468 * any buffer transformations. Returns Rect::INVALID_RECT if the layer has no buffer or the
469 * layer does not have a display frame and its parent is not bounded.
Peiyong Linf243e5e2020-08-22 17:40:59 -0700470 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000471 Rect getBufferSize(const Layer::State&) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700472
473 /**
474 * Returns the source bounds. If the bounds are not defined, it is inferred from the
475 * buffer size. Failing that, the bounds are determined from the passed in parent bounds.
476 * For the root layer, this is the display viewport size.
477 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000478 FloatRect computeSourceBounds(const FloatRect& parentBounds) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700479 virtual FrameRate getFrameRateForLayerTree() const;
480
Patrick Williamsbb25f802022-08-30 23:02:34 +0000481 bool getTransformToDisplayInverse() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700482
483 // Returns how rounded corners should be drawn for this layer.
Vishnu Nair9dbf8e82021-09-16 16:24:47 -0700484 // A layer can override its parent's rounded corner settings if the parent's rounded
485 // corner crop does not intersect with its own rounded corner crop.
Vishnu Nair8fc721b2022-12-22 20:06:32 +0000486 virtual frontend::RoundedCornerState getRoundedCornerState() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700487
Vishnu Naire14c6b32022-08-06 04:20:15 +0000488 bool hasRoundedCorners() const { return getRoundedCornerState().hasRoundedCorners(); }
Leon Scroggins IIIf8a18312021-04-01 16:38:25 -0400489
Patrick Williamsbb25f802022-08-30 23:02:34 +0000490 PixelFormat getPixelFormat() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700491 /**
Patrick Williamsbb25f802022-08-30 23:02:34 +0000492 * Return whether this layer needs an input info. We generate InputWindowHandles for all
493 * non-cursor buffered layers regardless of whether they have an InputChannel. This is to enable
494 * the InputDispatcher to do PID based occlusion detection.
Peiyong Linf243e5e2020-08-22 17:40:59 -0700495 */
Patrick Williamsbb25f802022-08-30 23:02:34 +0000496 bool needsInputInfo() const {
497 return (hasInputInfo() || hasBufferOrSidebandStream()) && !mPotentialCursor;
498 }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700499
500 // Implements RefBase.
501 void onFirstRef() override;
502
Patrick Williamsbb25f802022-08-30 23:02:34 +0000503 struct BufferInfo {
504 nsecs_t mDesiredPresentTime;
505 std::shared_ptr<FenceTime> mFenceTime;
506 sp<Fence> mFence;
507 uint32_t mTransform{0};
508 ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
509 Rect mCrop;
510 uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
511 Region mSurfaceDamage;
512 HdrMetadata mHdrMetadata;
513 int mApi;
514 PixelFormat mPixelFormat{PIXEL_FORMAT_NONE};
515 bool mTransformToDisplayInverse{false};
516
517 std::shared_ptr<renderengine::ExternalTexture> mBuffer;
518 uint64_t mFrameNumber;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000519
520 bool mFrameLatencyNeeded{false};
Sally Qi963049b2023-03-23 14:06:21 -0700521 float mDesiredHdrSdrRatio = 1.f;
Patrick Williamsbb25f802022-08-30 23:02:34 +0000522 };
523
524 BufferInfo mBufferInfo;
525
Peiyong Linf243e5e2020-08-22 17:40:59 -0700526 // implements compositionengine::LayerFE
Patrick Williamsbb25f802022-08-30 23:02:34 +0000527 const compositionengine::LayerFECompositionState* getCompositionState() const;
528 bool fenceHasSignaled() const;
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000529 void onPreComposition(nsecs_t refreshStartTime);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000530 void onLayerDisplayed(ftl::SharedFuture<FenceResult>);
Robert Carrccab4242021-09-28 16:53:03 -0700531
Vishnu Naire14c6b32022-08-06 04:20:15 +0000532 void setWasClientComposed(const sp<Fence>& fence) {
Robert Carrccab4242021-09-28 16:53:03 -0700533 mLastClientCompositionFence = fence;
Robert Carr05da0082022-05-25 23:29:34 -0700534 mClearClientCompositionFenceOnLayerDisplayed = false;
Robert Carrccab4242021-09-28 16:53:03 -0700535 }
536
Vishnu Naire14c6b32022-08-06 04:20:15 +0000537 const char* getDebugName() const;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700538
Peiyong Linf243e5e2020-08-22 17:40:59 -0700539 bool setShadowRadius(float shadowRadius);
540
541 // Before color management is introduced, contents on Android have to be
542 // desaturated in order to match what they appears like visually.
543 // With color management, these contents will appear desaturated, thus
544 // needed to be saturated so that they match what they are designed for
545 // visually.
546 bool isLegacyDataSpace() const;
547
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800548 uint32_t getTransactionFlags() const { return mTransactionFlags; }
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700549
Chavi Weingarten076acac2023-01-19 17:20:43 +0000550 static bool computeTrustedPresentationState(const FloatRect& bounds,
551 const FloatRect& sourceBounds,
552 const Region& coveredRegion,
553 const FloatRect& screenBounds, float,
554 const ui::Transform&,
555 const TrustedPresentationThresholds&);
Vishnu Nair781d7252023-01-30 18:16:01 +0000556 void updateTrustedPresentationState(const DisplayDevice* display,
557 const frontend::LayerSnapshot* snapshot, int64_t time_in_ms,
Chavi Weingarten076acac2023-01-19 17:20:43 +0000558 bool leaveState);
559
560 inline bool hasTrustedPresentationListener() {
561 return mTrustedPresentationListener.callbackInterface != nullptr;
562 }
563
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700564 // Sets the masked bits.
565 void setTransactionFlags(uint32_t mask);
566
567 // Clears and returns the masked bits.
568 uint32_t clearTransactionFlags(uint32_t mask);
Mathias Agopian13127d82013-03-05 17:47:11 -0800569
Vishnu Nair4351ad52019-02-11 14:13:02 -0800570 FloatRect getBounds(const Region& activeTransparentRegion) const;
571 FloatRect getBounds() const;
Vishnu Nairfed7c122023-03-18 01:54:43 +0000572 Rect getInputBoundsInDisplaySpace(const FloatRect& insetBounds,
573 const ui::Transform& displayTransform);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800574
575 // Compute bounds for the layer and cache the results.
Vishnu Nairc97b8db2019-10-29 18:19:35 -0700576 void computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float shadowRadius);
Vishnu Nair4351ad52019-02-11 14:13:02 -0800577
Vishnu Naire14c6b32022-08-06 04:20:15 +0000578 int32_t getSequence() const { return sequence; }
Pablo Ceballos40845df2016-01-25 17:41:15 -0800579
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700580 // For tracing.
581 // TODO: Replace with raw buffer id from buffer metadata when that becomes available.
582 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces
583 // creates its tracks by buffer id and has no way of associating a buffer back to the process
584 // that created it, the current implementation is only sufficient for cases where a buffer is
585 // only used within a single layer.
chaviwd62d3062019-09-04 14:48:02 -0700586 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; }
Mikael Pessa2e1608f2019-07-19 11:25:35 -0700587
Mathias Agopian13127d82013-03-05 17:47:11 -0800588 /*
589 * isSecure - true if this surface is secure, that is if it prevents
Peiyong Lin05cc0112020-10-14 16:16:37 -0700590 * screenshots or VNC servers. A surface can be set to be secure by the
591 * application, being secure doesn't mean the surface has DRM contents.
Mathias Agopian13127d82013-03-05 17:47:11 -0800592 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800593 bool isSecure() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800594
595 /*
Robert Carr1f0a16a2016-10-24 16:27:39 -0700596 * isHiddenByPolicy - true if this layer has been forced invisible.
597 * just because this is false, doesn't mean isVisible() is true.
598 * For example if this layer has no active buffer, it may not be hidden by
599 * policy, but it still can not be visible.
600 */
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800601 bool isHiddenByPolicy() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700602
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700603 // True if the layer should be skipped in screenshots, screen recordings,
604 // and mirroring to external or virtual displays.
605 bool isInternalDisplayOverlay() const;
606
607 ui::LayerFilter getOutputFilter() const {
608 return {getLayerStack(), isInternalDisplayOverlay()};
609 }
610
Robert Carr2e102c92018-10-23 12:11:15 -0700611 bool isRemovedFromCurrentState() const;
chaviw8b3871a2017-11-01 17:41:01 -0700612
Vishnu Naird8f5e9f2022-02-03 10:23:28 -0800613 LayerProto* writeToProto(LayersProto& layersProto, uint32_t traceFlags);
Vishnu Nairea6ff812023-02-27 17:41:39 +0000614 void writeCompositionStateToProto(LayerProto* layerProto);
chaviw08f3cb22020-01-13 13:17:21 -0800615
Vishnu Nair8406fd72019-07-30 11:29:31 -0700616 // Write states that are modified by the main thread. This includes drawing
617 // state as well as buffer data. This should be called in the main or tracing
618 // thread.
Vishnu Naird8f5e9f2022-02-03 10:23:28 -0800619 void writeToProtoDrawingState(LayerProto* layerInfo);
Vishnu Nair8406fd72019-07-30 11:29:31 -0700620 // Write drawing or current state. If writing current state, the caller should hold the
621 // external mStateLock. If writing drawing state, this function should be called on the
622 // main or tracing thread.
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200623 void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet,
Vishnu Nair00b90132021-11-05 14:03:40 -0700624 uint32_t traceFlags = LayerTracing::TRACE_ALL);
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800625
chaviw98318de2021-05-19 16:45:23 -0500626 gui::WindowInfo::Type getWindowType() const { return mWindowType; }
Peiyong Lin97067b02019-03-29 17:34:45 +0000627
chaviw74b03172019-08-19 11:09:03 -0700628 void updateMirrorInfo();
chaviw74b03172019-08-19 11:09:03 -0700629
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700630 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700631 * doTransaction - process the transaction. This is a good place to figure
632 * out which attributes of the surface have changed.
633 */
Vishnu Naira156f482023-02-22 00:23:38 +0000634 virtual uint32_t doTransaction(uint32_t transactionFlags);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700635
636 /*
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700637 * Remove relative z for the layer if its relative parent is not part of the
638 * provided layer tree.
639 */
640 void removeRelativeZ(const std::vector<Layer*>& layersInTree);
641
642 /*
643 * Remove from current state and mark for removal.
644 */
Josh Gao194ff392022-09-08 16:19:29 -0700645 void removeFromCurrentState() REQUIRES(mFlinger->mStateLock);
Vishnu Nairda9c85a2019-06-03 17:26:48 -0700646
647 /*
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800648 * called with the state lock from a binder thread when the layer is
Chia-I Wuc6657022017-08-15 11:18:17 -0700649 * removed from the current list to the pending removal list
650 */
Josh Gao194ff392022-09-08 16:19:29 -0700651 void onRemovedFromCurrentState() REQUIRES(mFlinger->mStateLock);
Chia-I Wuc6657022017-08-15 11:18:17 -0700652
chaviw61626f22018-11-15 16:26:27 -0800653 /*
654 * Called when the layer is added back to the current state list.
655 */
656 void addToCurrentState();
657
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700658 /*
659 * Sets display transform hint on BufferLayerConsumer.
660 */
661 void updateTransformHint(ui::Transform::RotationFlags);
Vishnu Nair71fcf912022-10-18 09:14:20 -0700662 void skipReportingTransformHint();
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800663 inline const State& getDrawingState() const { return mDrawingState; }
Robert Carr6a160312021-05-17 12:08:20 -0700664 inline State& getDrawingState() { return mDrawingState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800665
Huihong Luo05539a12022-02-23 10:29:40 -0800666 gui::LayerDebugInfo getLayerDebugInfo(const DisplayDevice*) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800667
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700668 void miniDump(std::string& result, const DisplayDevice&) const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800669 void dumpFrameStats(std::string& result) const;
Vishnu Nair76554eb2022-12-09 03:38:36 +0000670 void dumpOffscreenDebugInfo(std::string& result) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700671 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700672 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700673 void getFrameStats(FrameStats* outStats) const;
Brian Anderson5ea5e592016-12-01 16:54:33 -0800674 void onDisconnect();
Pablo Ceballosce796e72016-02-04 19:10:51 -0800675
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800676 ui::Transform getTransform() const;
Garfield Tan2c1782c2022-02-16 15:25:05 -0800677 bool isTransformValid() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700678
Robert Carr6452f122017-03-21 10:41:29 -0700679 // Returns the Alpha of the Surface, accounting for the Alpha
680 // of parent Surfaces in the hierarchy (alpha's will be multiplied
681 // down the hierarchy).
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800682 half getAlpha() const;
683 half4 getColor() const;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800684 int32_t getBackgroundBlurRadius() const;
Vishnu Nairb87d94f2020-02-13 09:17:36 -0800685 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; };
Robert Carr6452f122017-03-21 10:41:29 -0700686
Vishnu Nair6213bd92020-05-08 17:42:25 -0700687 // Returns the transform hint set by Window Manager on the layer or one of its parents.
688 // This traverses the current state because the data is needed when creating
689 // the layer(off drawing thread) and the hint should be available before the producer
690 // is ready to acquire a buffer.
691 ui::Transform::RotationFlags getFixedTransformHint() const;
692
Edgar Arriaga844fa672020-01-16 14:21:42 -0800693 /**
694 * Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder
695 * which will not emit children who have relativeZOrder to another layer, this method
696 * just directly emits all children. It also emits them in no particular order.
697 * So this method is not suitable for graphical operations, as it doesn't represent
698 * the scene state, but it's also more efficient than traverseInZOrder and so useful for
699 * book-keeping.
700 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200701 void traverse(LayerVector::StateSet, const LayerVector::Visitor&);
702 void traverseInReverseZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
703 void traverseInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
Vishnu Nair787aa782023-03-17 13:46:46 -0700704 void traverseChildren(const LayerVector::Visitor&);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700705
chaviw4b129c22018-04-09 16:19:43 -0700706 /**
707 * Traverse only children in z order, ignoring relative layers that are not children of the
708 * parent.
709 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200710 void traverseChildrenInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
chaviwa76b2712017-09-20 12:02:26 -0700711
Vishnu Nair787aa782023-03-17 13:46:46 -0700712 size_t getDescendantCount() const;
713 size_t getChildrenCount() const { return mDrawingChildren.size(); }
714 bool isHandleAlive() const { return mHandleAlive; }
715 bool onHandleDestroyed() { return mHandleAlive = false; }
Valerie Hauc5686802019-11-22 14:18:09 -0800716
717 // ONLY CALL THIS FROM THE LAYER DTOR!
718 // See b/141111965. We need to add current children to offscreen layers in
719 // the layer dtor so as not to dangle layers. Since the layer has not
720 // committed its transaction when the layer is destroyed, we must add
721 // current children. This is safe in the dtor as we will no longer update
722 // the current state, but should not be called anywhere else!
723 LayerVector& getCurrentChildren() { return mCurrentChildren; }
724
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200725 void addChild(const sp<Layer>&);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700726 // Returns index if removed, or negative value otherwise
727 // for symmetry with Vector::remove
728 ssize_t removeChild(const sp<Layer>& layer);
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000729 sp<Layer> getParent() const { return mCurrentParent.promote(); }
Vishnu Nair14d218b2021-07-13 13:57:39 -0700730
731 // Should be called with the surfaceflinger statelock held
732 bool isAtRoot() const { return mIsAtRoot; }
733 void setIsAtRoot(bool isAtRoot) { mIsAtRoot = isAtRoot; }
734
Robert Carr1f0a16a2016-10-24 16:27:39 -0700735 bool hasParent() const { return getParent() != nullptr; }
Vishnu Nair4351ad52019-02-11 14:13:02 -0800736 Rect getScreenBounds(bool reduceTransparentRegion = true) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700737 bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
Robert Carr503c7042017-09-27 15:06:08 -0700738 bool setChildRelativeLayer(const sp<Layer>& childLayer,
739 const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700740
741 // Copy the current list of children to the drawing state. Called by
742 // SurfaceFlinger to complete a transaction.
743 void commitChildList();
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200744 int32_t getZ(LayerVector::StateSet) const;
Vishnu Nair4351ad52019-02-11 14:13:02 -0800745
Vishnu Nairefc42e22019-12-03 17:36:12 -0800746 /**
747 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
748 * INVALID_RECT if the layer has no buffer and no crop.
749 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer
750 * bounds are constrained by its parent bounds.
751 */
752 Rect getCroppedBufferSize(const Layer::State& s) const;
753
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200754 bool setFrameRate(FrameRate);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700755
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000756 virtual void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& /*info*/) {}
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000757 void setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info, nsecs_t postTime);
758 void setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info,
759 nsecs_t postTime);
760
761 void addSurfaceFrameDroppedForBuffer(
762 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame);
763 void addSurfaceFramePresentedForBuffer(
764 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime,
765 nsecs_t currentLatchTime);
766
767 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForTransaction(
768 const FrameTimelineInfo& info, nsecs_t postTime);
769 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForBuffer(
770 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName);
Ady Abraham74e17562020-08-24 18:18:19 -0700771
Chavi Weingarten328a8312023-01-26 21:17:52 +0000772 bool setTrustedPresentationInfo(TrustedPresentationThresholds const& thresholds,
Chavi Weingarten076acac2023-01-19 17:20:43 +0000773 TrustedPresentationListener const& listener);
774
Peiyong Linf243e5e2020-08-22 17:40:59 -0700775 // Creates a new handle each time, so we only expect
776 // this to be called once.
777 sp<IBinder> getHandle();
778 const std::string& getName() const { return mName; }
779 bool getPremultipledAlpha() const;
chaviw98318de2021-05-19 16:45:23 -0500780 void setInputInfo(const gui::WindowInfo& info);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700781
Prabir Pradhanda0f62c2022-07-22 19:53:04 +0000782 struct InputDisplayArgs {
783 const ui::Transform* transform = nullptr;
784 bool isSecure = false;
785 };
786 gui::WindowInfo fillInputInfo(const InputDisplayArgs& displayArgs);
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700787
Peiyong Linf243e5e2020-08-22 17:40:59 -0700788 /**
789 * Returns whether this layer has an explicitly set input-info.
790 */
791 bool hasInputInfo() const;
792
Vishnu Nair8fc721b2022-12-22 20:06:32 +0000793 // Sets the gui::GameMode for the tree rooted at this layer. A layer in the tree inherits this
794 // gui::GameMode unless it (or an ancestor) has GAME_MODE_METADATA.
795 void setGameModeForTree(gui::GameMode);
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -0700796
Vishnu Nair8fc721b2022-12-22 20:06:32 +0000797 void setGameMode(gui::GameMode gameMode) { mGameMode = gameMode; }
798 gui::GameMode getGameMode() const { return mGameMode; }
Adithya Srinivasanac977e62021-05-21 22:50:56 +0000799
Ady Abraham62a0be22020-12-08 16:54:10 -0800800 virtual uid_t getOwnerUid() const { return mOwnerUid; }
Peiyong Linf243e5e2020-08-22 17:40:59 -0700801
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700802 pid_t getOwnerPid() { return mOwnerPid; }
803
Peiyong Linf243e5e2020-08-22 17:40:59 -0700804 // This layer is not a clone, but it's the parent to the cloned hierarchy. The
805 // variable mClonedChild represents the top layer that will be cloned so this
806 // layer will be the parent of mClonedChild.
807 // The layers in the cloned hierarchy will match the lifetime of the real layers. That is
808 // if the real layer is destroyed, then the clone layer will also be destroyed.
809 sp<Layer> mClonedChild;
Robert Carr6a0382d2021-07-01 15:57:17 -0700810 bool mHadClonedChild = false;
811 void setClonedChild(const sp<Layer>& mClonedChild);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700812
813 mutable bool contentDirty{false};
814 Region surfaceDamageRegion;
815
816 // Layer serial number. This gives layers an explicit ordering, so we
817 // have a stable sort order when their layer stack and Z-order are
818 // the same.
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800819 const int32_t sequence;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700820
821 bool mPendingHWCDestroy{false};
Steven Thomas3172e202020-01-06 19:25:30 -0800822
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700823 bool backpressureEnabled() const {
824 return mDrawingState.flags & layer_state_t::eEnableBackpressure;
825 }
Vishnu Nairf6eddb62021-01-27 22:02:11 -0800826
John Reckcdb4ed72021-02-04 13:39:33 -0500827 bool setStretchEffect(const StretchEffect& effect);
John Reckc00c6692021-02-16 11:37:33 -0500828 StretchEffect getStretchEffect() const;
Tianhao Yao10cea3c2022-03-30 01:37:22 +0000829 bool enableBorder(bool shouldEnable, float width, const half4& color);
Tianhao Yao67dd7122022-02-22 17:48:33 +0000830 bool isBorderEnabled();
Tianhao Yao10cea3c2022-03-30 01:37:22 +0000831 float getBorderWidth();
832 const half4& getBorderColor();
John Reckcdb4ed72021-02-04 13:39:33 -0500833
Patrick Williamsbb25f802022-08-30 23:02:34 +0000834 bool setBufferCrop(const Rect& /* bufferCrop */);
835 bool setDestinationFrame(const Rect& /* destinationFrame */);
836 // See mPendingBufferTransactions
837 void decrementPendingBufferCount();
838 std::atomic<int32_t>* getPendingBufferCounter() { return &mPendingBufferTransactions; }
839 std::string getPendingBufferCounterName() { return mBlastTransactionName; }
840 bool updateGeometry();
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800841
Patrick Williamsbb25f802022-08-30 23:02:34 +0000842 bool simpleBufferUpdate(const layer_state_t&) const;
843
844 static bool isOpaqueFormat(PixelFormat format);
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000845
846 // Updates the LayerSnapshot. This must be called prior to sending layer data to
847 // CompositionEngine or RenderEngine (i.e. before calling CompositionEngine::present or
Vishnu Naire14c6b32022-08-06 04:20:15 +0000848 // LayerFE::prepareClientComposition).
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000849 //
850 // TODO(b/238781169) Remove direct calls to RenderEngine::drawLayers that don't go through
851 // CompositionEngine to create a single path for composing layers.
Vishnu Nairba354102022-08-01 00:14:18 +0000852 void updateSnapshot(bool updateGeometry);
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000853 void updateMetadataSnapshot(const LayerMetadata& parentMetadata);
854 void updateRelativeMetadataSnapshot(const LayerMetadata& relativeLayerMetadata,
855 std::unordered_set<Layer*>& visited);
Vishnu Nair332e6ba2023-01-25 17:16:19 -0800856 sp<Layer> getClonedFrom() const {
857 return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr;
858 }
859 bool isClone() { return mClonedFrom != nullptr; }
860
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000861 bool willPresentCurrentTransaction() const;
Ady Abraham9dada822022-02-03 10:26:59 -0800862
liulijuneb489f62022-10-17 22:02:14 +0800863 void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
864 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
865 const sp<Fence>& releaseFence);
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000866 bool setFrameRateForLayerTreeLegacy(FrameRate);
867 bool setFrameRateForLayerTree(FrameRate, const scheduler::LayerProps&);
868 void recordLayerHistoryBufferUpdate(const scheduler::LayerProps&);
869 void recordLayerHistoryAnimationTx(const scheduler::LayerProps&);
870 auto getLayerProps() const {
871 return scheduler::LayerProps{
872 .visible = isVisible(),
873 .bounds = getBounds(),
874 .transform = getTransform(),
875 .setFrameRateVote = getFrameRateForLayerTree(),
876 .frameRateSelectionPriority = getFrameRateSelectionPriority(),
877 };
878 };
Vishnu Nairc09c0232023-03-02 03:22:35 +0000879 bool hasBuffer() const { return mBufferInfo.mBuffer != nullptr; }
Vishnu Nairb76d99a2023-03-19 18:22:31 -0700880 void setTransformHint(std::optional<ui::Transform::RotationFlags> transformHint) {
881 mTransformHint = transformHint;
882 }
liulijuneb489f62022-10-17 22:02:14 +0800883
Josh Gao194ff392022-09-08 16:19:29 -0700884 // Exposed so SurfaceFlinger can assert that it's held
885 const sp<SurfaceFlinger> mFlinger;
886
Mathias Agopian13127d82013-03-05 17:47:11 -0800887protected:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700888 // For unit tests
889 friend class TestableSurfaceFlinger;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800890 friend class FpsReporterTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700891 friend class RefreshRateSelectionTest;
892 friend class SetFrameRateTest;
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000893 friend class TransactionFrameTracerTest;
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +0000894 friend class TransactionSurfaceFrameTest;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700895
896 virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000897 void preparePerFrameCompositionState();
898 void preparePerFrameBufferCompositionState();
899 void preparePerFrameEffectsCompositionState();
Vishnu Naira156f482023-02-22 00:23:38 +0000900 virtual void commitTransaction(State& stateToCommit);
Patrick Williamsbb25f802022-08-30 23:02:34 +0000901 void gatherBufferInfo();
902 void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700903
Peiyong Linf243e5e2020-08-22 17:40:59 -0700904 bool isClonedFromAlive() { return getClonedFrom() != nullptr; }
905
Vishnu Nair3bb11d02021-11-26 09:24:11 -0800906 void cloneDrawingState(const Layer* from);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700907 void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
908 void updateClonedChildren(const sp<Layer>& mirrorRoot,
909 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
910 void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
911 void addChildToDrawing(const sp<Layer>&);
912 void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
913
Peiyong Linf243e5e2020-08-22 17:40:59 -0700914 void prepareBasicGeometryCompositionState();
915 void prepareGeometryCompositionState();
916 void prepareCursorCompositionState();
917
918 uint32_t getEffectiveUsage(uint32_t usage) const;
919
920 /**
921 * Setup rounded corners coordinates of this layer, taking into account the layer bounds and
922 * crop coordinates, transforming them into layer space.
923 */
924 void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const;
925 void setParent(const sp<Layer>&);
926 LayerVector makeTraversalList(LayerVector::StateSet, bool* outSkipRelativeZUsers);
927 void addZOrderRelative(const wp<Layer>& relative);
928 void removeZOrderRelative(const wp<Layer>& relative);
929 compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const;
930 bool usingRelativeZ(LayerVector::StateSet) const;
931
Patrick Williamsbb25f802022-08-30 23:02:34 +0000932 virtual ui::Transform getInputTransform() const;
Prabir Pradhan6fa425a2021-12-16 07:16:04 -0800933 /**
934 * Get the bounds in layer space within which this layer can receive input.
935 *
936 * These bounds are used to:
937 * - Determine the input frame for the layer to be used for occlusion detection; and
938 * - Determine the coordinate space within which the layer will receive input. The top-left of
939 * this rect will be the origin of the coordinate space that the input events sent to the
940 * layer will be in (prior to accounting for surface insets).
941 *
942 * The layer can still receive touch input if these bounds are invalid if
943 * "replaceTouchableRegionWithCrop" is specified. In this case, the layer will receive input
944 * in this layer's space, regardless of the specified crop layer.
945 */
Vishnu Nairfed7c122023-03-18 01:54:43 +0000946 std::pair<FloatRect, bool> getInputBounds(bool fillParentBounds) const;
chaviw39d01472021-04-08 14:26:24 -0500947
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700948 bool mPremultipliedAlpha{true};
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700949 const std::string mName;
950 const std::string mTransactionName{"TX - " + mName};
Mathias Agopian13127d82013-03-05 17:47:11 -0800951
Vishnu Nair8406fd72019-07-30 11:29:31 -0700952 // These are only accessed by the main thread or the tracing thread.
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800953 State mDrawingState;
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800954
Chavi Weingarten076acac2023-01-19 17:20:43 +0000955 TrustedPresentationThresholds mTrustedPresentationThresholds;
956 TrustedPresentationListener mTrustedPresentationListener;
957 bool mLastComputedTrustedPresentationState = false;
958 bool mLastReportedTrustedPresentationState = false;
959 int64_t mEnteredTrustedPresentationStateTime = -1;
960
Robert Carr38d25002021-06-11 14:30:09 -0700961 uint32_t mTransactionFlags{0};
Robert Carr6a160312021-05-17 12:08:20 -0700962 // Updated in doTransaction, used to track the last sequence number we
963 // committed. Currently this is really only used for updating visible
964 // regions.
965 int32_t mLastCommittedTxSequence = -1;
Dan Stoza7dde5992015-05-22 09:51:44 -0700966
Brian Andersond6927fb2016-07-23 23:37:30 -0700967 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800968 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700969
970 // main thread
Lloyd Pique0b785d82018-12-04 17:25:27 -0800971 sp<NativeHandle> mSidebandStream;
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000972 // False if the buffer and its contents have been previously used for GPU
973 // composition, true otherwise.
974 bool mIsActiveBufferUpdatedForGpu = true;
975
Robert Carrc3574f72016-03-24 12:19:32 -0700976 // We encode unset as -1.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700977 std::atomic<uint64_t> mCurrentFrameNumber{0};
Mathias Agopian13127d82013-03-05 17:47:11 -0800978 // Whether filtering is needed b/c of the drawingstate
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700979 bool mNeedsFiltering{false};
David Sodman0c69cad2017-08-21 12:12:51 -0700980
Robert Carr6a160312021-05-17 12:08:20 -0700981 std::atomic<bool> mRemovedFromDrawingState{false};
chaviw8b3871a2017-11-01 17:41:01 -0700982
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700983 // page-flip thread (currently main thread)
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700984 bool mProtectedByApp{false}; // application requires protected path to external sink
Mathias Agopian13127d82013-03-05 17:47:11 -0800985
986 // protected by mLock
987 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -0700988
Mathias Agopian13127d82013-03-05 17:47:11 -0800989 const wp<Client> mClientRef;
Riley Andrews03414a12014-07-01 14:22:59 -0700990
991 // This layer can be a cursor on some displays.
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700992 bool mPotentialCursor{false};
Dan Stoza6b9454d2014-11-07 16:00:59 -0800993
Robert Carr88d76cd2021-06-22 16:23:51 -0700994 LayerVector mCurrentChildren{LayerVector::StateSet::Current};
Lloyd Pique42ab75e2018-09-12 20:46:03 -0700995 LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};
Robert Carr1f0a16a2016-10-24 16:27:39 -0700996
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000997 wp<Layer> mCurrentParent;
998 wp<Layer> mDrawingParent;
David Sodman9eeae692017-11-02 10:53:32 -0700999
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001000 // Window types from WindowManager.LayoutParams
chaviw98318de2021-05-19 16:45:23 -05001001 const gui::WindowInfo::Type mWindowType;
Ady Abraham8f1ee7f2019-04-05 10:32:50 -07001002
Alec Mouri9a29e672020-09-14 12:39:14 -07001003 // The owner of the layer. If created from a non system process, it will be the calling uid.
1004 // If created from a system process, the value can be passed in.
1005 uid_t mOwnerUid;
1006
Adithya Srinivasan9febda82020-10-19 10:49:41 -07001007 // The owner pid of the layer. If created from a non system process, it will be the calling pid.
1008 // If created from a system process, the value can be passed in.
1009 pid_t mOwnerPid;
1010
Adithya Srinivasanb9a7dab2021-01-14 23:49:46 +00001011 // Keeps track of the time SF latched the last buffer from this layer.
1012 // Used in buffer stuffing analysis in FrameTimeline.
1013 nsecs_t mLastLatchTime = 0;
1014
Robert Carr6a160312021-05-17 12:08:20 -07001015 mutable bool mDrawingStateModified = false;
Robert Carr0758e5d2021-03-11 22:15:04 -08001016
Robert Carrccab4242021-09-28 16:53:03 -07001017 sp<Fence> mLastClientCompositionFence;
Robert Carr05da0082022-05-25 23:29:34 -07001018 bool mClearClientCompositionFenceOnLayerDisplayed = false;
chaviw4b129c22018-04-09 16:19:43 -07001019private:
Patrick Williamsbb25f802022-08-30 23:02:34 +00001020 friend class SlotGenerationTest;
1021 friend class TransactionFrameTracerTest;
1022 friend class TransactionSurfaceFrameTest;
1023
1024 bool getAutoRefresh() const { return mDrawingState.autoRefresh; }
1025 bool getSidebandStreamChanged() const { return mSidebandStreamChanged; }
1026
1027 std::atomic<bool> mSidebandStreamChanged{false};
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001028
Peiyong Linf243e5e2020-08-22 17:40:59 -07001029 // Returns true if the layer can draw shadows on its border.
1030 virtual bool canDrawShadows() const { return true; }
1031
Leon Scroggins III2e1aa182021-12-01 17:33:12 -05001032 aidl::android::hardware::graphics::composer3::Composition getCompositionType(
1033 const DisplayDevice&) const;
Dominik Laskowskib7251f42020-04-20 17:42:59 -07001034
chaviw4b129c22018-04-09 16:19:43 -07001035 /**
1036 * Returns an unsorted vector of all layers that are part of this tree.
1037 * That includes the current layer and all its descendants.
1038 */
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02001039 std::vector<Layer*> getLayersInTree(LayerVector::StateSet);
chaviw4b129c22018-04-09 16:19:43 -07001040 /**
1041 * Traverses layers that are part of this tree in the correct z order.
1042 * layersInTree must be sorted before calling this method.
1043 */
1044 void traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
Marin Shalamanov6ad317c2020-07-29 23:34:07 +02001045 LayerVector::StateSet, const LayerVector::Visitor&);
1046 LayerVector makeChildrenTraversalList(LayerVector::StateSet,
chaviw4b129c22018-04-09 16:19:43 -07001047 const std::vector<Layer*>& layersInTree);
Vishnu Nair4351ad52019-02-11 14:13:02 -08001048
Ady Abraham60e42ea2020-03-09 19:17:31 -07001049 void updateTreeHasFrameRateVote();
Ady Abrahama850c182021-08-04 13:04:37 -07001050 bool propagateFrameRateForLayerTree(FrameRate parentFrameRate, bool* transactionNeeded);
Peiyong Linf243e5e2020-08-22 17:40:59 -07001051 void setZOrderRelativeOf(const wp<Layer>& relativeOf);
Winson Chunga30f7c92021-06-29 15:42:56 -07001052 bool isTrustedOverlay() const;
Vishnu Naira066d902021-09-13 18:40:17 -07001053 gui::DropInputMode getDropInputMode() const;
1054 void handleDropInputMode(gui::WindowInfo& info) const;
Peiyong Linf243e5e2020-08-22 17:40:59 -07001055
1056 // Find the root of the cloned hierarchy, this means the first non cloned parent.
1057 // This will return null if first non cloned parent is not found.
1058 sp<Layer> getClonedRoot();
1059
1060 // Finds the top most layer in the hierarchy. This will find the root Layer where the parent is
1061 // null.
1062 sp<Layer> getRootLayer();
Ady Abraham60e42ea2020-03-09 19:17:31 -07001063
Bernardo Rufinoa9d0a532021-06-11 15:59:12 +01001064 // Fills in the touch occlusion mode of the first parent (including this layer) that
1065 // hasInputInfo() or no-op if no such parent is found.
chaviw98318de2021-05-19 16:45:23 -05001066 void fillTouchOcclusionMode(gui::WindowInfo& info);
Bernardo Rufinoa9d0a532021-06-11 15:59:12 +01001067
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001068 // Fills in the frame and transform info for the gui::WindowInfo.
Prabir Pradhanc9589c12021-09-22 06:11:43 -07001069 void fillInputFrameInfo(gui::WindowInfo&, const ui::Transform& screenToDisplay);
chaviw7e72caf2020-12-02 16:50:43 -08001070
Patrick Williamsbb25f802022-08-30 23:02:34 +00001071 inline void tracePendingBufferCount(int32_t pendingBuffers);
1072
1073 // Latch sideband stream and returns true if the dirty region should be updated.
1074 bool latchSidebandStream(bool& recomputeVisibleRegions);
1075
1076 bool hasFrameUpdate() const;
1077
Vishnu Naird47bcee2023-02-24 18:08:51 +00001078 void updateTexImage(nsecs_t latchTime, bool bgColorOnly = false);
Patrick Williamsbb25f802022-08-30 23:02:34 +00001079
1080 // Crop that applies to the buffer
1081 Rect computeBufferCrop(const State& s);
1082
Patrick Williamsbb25f802022-08-30 23:02:34 +00001083 void callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
1084 const sp<GraphicBuffer>& buffer, uint64_t framenumber,
1085 const sp<Fence>& releaseFence,
1086 uint32_t currentMaxAcquiredBufferCount);
1087
liulijuneb489f62022-10-17 22:02:14 +08001088 // Returns true if the transformed buffer size does not match the layer size and we need
1089 // to apply filtering.
1090 bool bufferNeedsFiltering() const;
1091
Patrick Williamsbb25f802022-08-30 23:02:34 +00001092 // Returns true if there is a valid color to fill.
1093 bool fillsColor() const;
1094 // Returns true if this layer has a blur value.
1095 bool hasBlur() const;
1096 bool hasEffect() const { return fillsColor() || drawShadows() || hasBlur(); }
1097 bool hasBufferOrSidebandStream() const {
1098 return ((mSidebandStream != nullptr) || (mBufferInfo.mBuffer != nullptr));
1099 }
1100
Vishnu Nair22491b82022-10-18 14:59:14 -07001101 bool hasBufferOrSidebandStreamInDrawing() const {
1102 return ((mDrawingState.sidebandStream != nullptr) || (mDrawingState.buffer != nullptr));
1103 }
1104
Patrick Williamsbb25f802022-08-30 23:02:34 +00001105 bool hasSomethingToDraw() const { return hasEffect() || hasBufferOrSidebandStream(); }
Vishnu Naire14c6b32022-08-06 04:20:15 +00001106
1107 void updateChildrenSnapshots(bool updateGeometry);
Patrick Williamsbb25f802022-08-30 23:02:34 +00001108
Pascal Muetschardf54181b2022-12-13 14:53:25 +01001109 // Fills the provided vector with the currently available JankData and removes the processed
1110 // JankData from the pending list.
1111 void transferAvailableJankData(const std::deque<sp<CallbackHandle>>& handles,
1112 std::vector<JankData>& jankData);
1113
Vishnu Nair4351ad52019-02-11 14:13:02 -08001114 // Cached properties computed from drawing state
Peiyong Lin74861ad2020-10-14 11:55:33 -07001115 // Effective transform taking into account parent transforms and any parent scaling, which is
1116 // a transform from the current layer coordinate space to display(screen) coordinate space.
Vishnu Nair4351ad52019-02-11 14:13:02 -08001117 ui::Transform mEffectiveTransform;
1118
1119 // Bounds of the layer before any transformation is applied and before it has been cropped
1120 // by its parents.
1121 FloatRect mSourceBounds;
1122
1123 // Bounds of the layer in layer space. This is the mSourceBounds cropped by its layer crop and
1124 // its parent bounds.
1125 FloatRect mBounds;
1126
1127 // Layer bounds in screen space.
1128 FloatRect mScreenBounds;
chaviw606e5cf2019-03-01 10:12:10 -08001129
Robert Carrc0df3122019-04-11 13:18:21 -07001130 bool mGetHandleCalled = false;
chaviw43cb3cb2019-05-31 15:23:41 -07001131
chaviwb4c6e582019-08-16 14:35:07 -07001132 // The current layer is a clone of mClonedFrom. This means that this layer will update it's
1133 // properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers,
1134 // this layer will update it's buffer. When mClonedFrom updates it's drawing state, children,
1135 // and relatives, this layer will update as well.
1136 wp<Layer> mClonedFrom;
Vishnu Nairc97b8db2019-10-29 18:19:35 -07001137
1138 // The inherited shadow radius after taking into account the layer hierarchy. This is the
1139 // final shadow radius for this layer. If a shadow is specified for a layer, then effective
1140 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius.
Vishnu Nairf37dcfb2019-11-16 07:37:09 -08001141 float mEffectiveShadowRadius = 0.f;
Lucas Dupinc3800b82020-10-02 16:24:48 -07001142
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07001143 // Game mode for the layer. Set by WindowManagerShell and recorded by SurfaceFlingerStats.
Vishnu Nair8fc721b2022-12-22 20:06:32 +00001144 gui::GameMode mGameMode = gui::GameMode::Unsupported;
Adithya Srinivasanac977e62021-05-21 22:50:56 +00001145
Lucas Dupinc3800b82020-10-02 16:24:48 -07001146 // A list of regions on this layer that should have blurs.
Galia Peychevae0acf382021-04-12 21:22:34 +02001147 const std::vector<BlurRegion> getBlurRegions() const;
Vishnu Nair14d218b2021-07-13 13:57:39 -07001148
1149 bool mIsAtRoot = false;
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08001150
1151 uint32_t mLayerCreationFlags;
Tianhao Yao67dd7122022-02-22 17:48:33 +00001152
Robert Carr88b85e12022-03-21 15:47:35 -07001153 bool findInHierarchy(const sp<Layer>&);
Tianhao Yao67dd7122022-02-22 17:48:33 +00001154
1155 bool mBorderEnabled = false;
Tianhao Yao10cea3c2022-03-30 01:37:22 +00001156 float mBorderWidth;
1157 half4 mBorderColor;
Patrick Williamsbb25f802022-08-30 23:02:34 +00001158
Vishnu Nairb76d99a2023-03-19 18:22:31 -07001159 void setTransformHintLegacy(ui::Transform::RotationFlags);
Patrick Williamsbb25f802022-08-30 23:02:34 +00001160
1161 const uint32_t mTextureName;
1162
1163 // Transform hint provided to the producer. This must be accessed holding
1164 // the mStateLock.
Vishnu Nairb76d99a2023-03-19 18:22:31 -07001165 ui::Transform::RotationFlags mTransformHintLegacy = ui::Transform::ROT_0;
Vishnu Nair71fcf912022-10-18 09:14:20 -07001166 bool mSkipReportingTransformHint = true;
Vishnu Nairb76d99a2023-03-19 18:22:31 -07001167 std::optional<ui::Transform::RotationFlags> mTransformHint = std::nullopt;
Patrick Williamsbb25f802022-08-30 23:02:34 +00001168
Patrick Williamsbb25f802022-08-30 23:02:34 +00001169 ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;
1170 uint64_t mPreviousReleasedFrameNumber = 0;
1171
1172 uint64_t mPreviousBarrierFrameNumber = 0;
1173
1174 bool mReleasePreviousBuffer = false;
1175
1176 // Stores the last set acquire fence signal time used to populate the callback handle's acquire
1177 // time.
1178 std::variant<nsecs_t, sp<Fence>> mCallbackHandleAcquireTimeOrFence = -1;
1179
1180 std::deque<std::shared_ptr<android::frametimeline::SurfaceFrame>> mPendingJankClassifications;
1181 // An upper bound on the number of SurfaceFrames in the pending classifications deque.
Vishnu Nair22491b82022-10-18 14:59:14 -07001182 static constexpr int kPendingClassificationMaxSurfaceFrames = 50;
Patrick Williamsbb25f802022-08-30 23:02:34 +00001183
1184 const std::string mBlastTransactionName{"BufferTX - " + mName};
1185 // This integer is incremented everytime a buffer arrives at the server for this layer,
1186 // and decremented when a buffer is dropped or latched. When changed the integer is exported
1187 // to systrace with ATRACE_INT and mBlastTransactionName. This way when debugging perf it is
1188 // possible to see when a buffer arrived at the server, and in which frame it latched.
1189 //
1190 // You can understand the trace this way:
1191 // - If the integer increases, a buffer arrived at the server.
1192 // - If the integer decreases in latchBuffer, that buffer was latched
1193 // - If the integer decreases in setBuffer or doTransaction, a buffer was dropped
1194 std::atomic<int32_t> mPendingBufferTransactions{0};
1195
1196 // Contains requested position and matrix updates. This will be applied if the client does
1197 // not specify a destination frame.
1198 ui::Transform mRequestedTransform;
1199
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001200 sp<LayerFE> mLegacyLayerFE;
1201 std::vector<std::pair<frontend::LayerHierarchy::TraversalPath, sp<LayerFE>>> mLayerFEs;
Vishnu Nair8fc721b2022-12-22 20:06:32 +00001202 std::unique_ptr<frontend::LayerSnapshot> mSnapshot =
1203 std::make_unique<frontend::LayerSnapshot>();
Vishnu Nair787aa782023-03-17 13:46:46 -07001204 bool mHandleAlive = false;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001205};
1206
Marin Shalamanov46084422020-10-13 12:33:42 +02001207std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate);
1208
Dominik Laskowski34157762018-10-31 13:07:19 -07001209} // namespace android