blob: 84fb82768608dd1aa280fa37d73966328ef2c20b [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_LAYER_H
18#define ANDROID_LAYER_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
Mathias Agopian13127d82013-03-05 17:47:11 -080023#include <utils/RefBase.h>
24#include <utils/String8.h>
25#include <utils/Timers.h>
26
Dan Stoza80d61162017-12-20 15:57:52 -080027#include <ui/FloatRect.h>
Svetoslavd85084b2014-03-20 10:28:31 -070028#include <ui/FrameStats.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080029#include <ui/GraphicBuffer.h>
30#include <ui/PixelFormat.h>
31#include <ui/Region.h>
32
33#include <gui/ISurfaceComposerClient.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070034#include <gui/LayerState.h>
David Sodman0cc69182017-11-17 12:12:07 -080035#include <gui/BufferQueue.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080036
Dan Stoza7dde5992015-05-22 09:51:44 -070037#include <list>
38
Mathias Agopian13127d82013-03-05 17:47:11 -080039#include "Client.h"
David Sodman41fdfc92017-11-06 16:09:56 -080040#include "FrameTracker.h"
Robert Carr1f0a16a2016-10-24 16:27:39 -070041#include "LayerVector.h"
Dan Stozab9b08832014-03-13 11:55:57 -070042#include "MonitoredProducer.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080043#include "SurfaceFlinger.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080044#include "Transform.h"
45
David Sodman41fdfc92017-11-06 16:09:56 -080046#include <layerproto/LayerProtoHeader.h>
Mathias Agopian13127d82013-03-05 17:47:11 -080047#include "DisplayHardware/HWComposer.h"
Chia-I Wuaaff73f2017-02-13 12:28:24 -080048#include "DisplayHardware/HWComposerBufferCache.h"
David Sodman41fdfc92017-11-06 16:09:56 -080049#include "RenderArea.h"
Mathias Agopian3f844832013-08-07 21:24:32 -070050#include "RenderEngine/Mesh.h"
Mathias Agopian49457ac2013-08-14 18:20:17 -070051#include "RenderEngine/Texture.h"
Mathias Agopian13127d82013-03-05 17:47:11 -080052
chaviw13fdc492017-06-27 12:40:18 -070053#include <math/vec4.h>
54
chaviw1d044282017-09-27 12:19:28 -070055using namespace android::surfaceflinger;
56
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080057namespace android {
58
59// ---------------------------------------------------------------------------
60
Mathias Agopian1f7bec62010-06-25 18:02:21 -070061class Client;
Mathias Agopian3e25fd82013-04-22 17:52:16 +020062class Colorizer;
Mathias Agopian13127d82013-03-05 17:47:11 -080063class DisplayDevice;
64class GraphicBuffer;
65class SurfaceFlinger;
Kalle Raitaa099a242017-01-11 11:17:29 -080066class LayerDebugInfo;
David Sodman9eeae692017-11-02 10:53:32 -070067class LayerBE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080068
Lloyd Pique4dccc412018-01-22 17:21:36 -080069namespace impl {
70class SurfaceInterceptor;
71}
72
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080073// ---------------------------------------------------------------------------
74
David Sodman0cc69182017-11-17 12:12:07 -080075struct CompositionInfo {
76 HWC2::Composition compositionType;
77 sp<GraphicBuffer> mBuffer = nullptr;
78 int mBufferSlot = BufferQueue::INVALID_BUFFER_SLOT;
79 struct {
80 HWComposer* hwc;
81 sp<Fence> fence;
82 HWC2::BlendMode blendMode;
83 Rect displayFrame;
84 float alpha;
85 FloatRect sourceCrop;
86 HWC2::Transform transform;
87 int z;
88 int type;
89 int appId;
90 Region visibleRegion;
91 Region surfaceDamage;
92 sp<NativeHandle> sidebandStream;
93 android_dataspace dataspace;
94 hwc_color_t color;
95 } hwc;
96 struct {
Lloyd Pique144e1162017-12-20 16:44:52 -080097 RE::RenderEngine* renderEngine;
David Sodman0cc69182017-11-17 12:12:07 -080098 Mesh* mesh;
99 } renderEngine;
100};
101
David Sodman9eeae692017-11-02 10:53:32 -0700102class LayerBE {
103public:
104 LayerBE();
105
106 // The mesh used to draw the layer in GLES composition mode
107 Mesh mMesh;
108
David Sodman6f65f3e2017-11-03 14:28:09 -0700109 // HWC items, accessed from the main thread
110 struct HWCInfo {
111 HWCInfo()
112 : hwc(nullptr),
113 layer(nullptr),
114 forceClientComposition(false),
115 compositionType(HWC2::Composition::Invalid),
116 clearClientTarget(false) {}
117
118 HWComposer* hwc;
119 HWC2::Layer* layer;
120 bool forceClientComposition;
121 HWC2::Composition compositionType;
122 bool clearClientTarget;
123 Rect displayFrame;
124 FloatRect sourceCrop;
125 HWComposerBufferCache bufferCache;
126 };
127
128 // A layer can be attached to multiple displays when operating in mirror mode
129 // (a.k.a: when several displays are attached with equal layerStack). In this
130 // case we need to keep track. In non-mirror mode, a layer will have only one
131 // HWCInfo. This map key is a display layerStack.
132 std::unordered_map<int32_t, HWCInfo> mHwcLayers;
David Sodman0cc69182017-11-17 12:12:07 -0800133
134 CompositionInfo compositionInfo;
David Sodman9eeae692017-11-02 10:53:32 -0700135};
136
David Sodman41fdfc92017-11-06 16:09:56 -0800137class Layer : public virtual RefBase {
Mathias Agopian13127d82013-03-05 17:47:11 -0800138 static int32_t sSequence;
139
Mathias Agopiand606de62010-05-10 20:06:11 -0700140public:
David Sodman9eeae692017-11-02 10:53:32 -0700141 LayerBE& getBE() { return mBE; }
142 LayerBE& getBE() const { return mBE; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800143 mutable bool contentDirty;
144 // regions below are in window-manager space
145 Region visibleRegion;
146 Region coveredRegion;
147 Region visibleNonTransparentRegion;
Dan Stozaee44edd2015-03-23 15:50:23 -0700148 Region surfaceDamageRegion;
Andy McFadden4df87bd2014-04-21 18:08:54 -0700149
150 // Layer serial number. This gives layers an explicit ordering, so we
151 // have a stable sort order when their layer stack and Z-order are
152 // the same.
Mathias Agopian13127d82013-03-05 17:47:11 -0800153 int32_t sequence;
154
155 enum { // flags for doTransaction()
156 eDontUpdateGeometryState = 0x00000001,
157 eVisibleRegion = 0x00000002,
158 };
159
160 struct Geometry {
161 uint32_t w;
162 uint32_t h;
Robert Carr3dcabfa2016-03-01 18:36:58 -0800163 Transform transform;
164
David Sodman41fdfc92017-11-06 16:09:56 -0800165 inline bool operator==(const Geometry& rhs) const {
166 return (w == rhs.w && h == rhs.h) && (transform.tx() == rhs.transform.tx()) &&
Robert Carr99e27f02016-06-16 15:18:02 -0700167 (transform.ty() == rhs.transform.ty());
Mathias Agopian13127d82013-03-05 17:47:11 -0800168 }
David Sodman41fdfc92017-11-06 16:09:56 -0800169 inline bool operator!=(const Geometry& rhs) const { return !operator==(rhs); }
Mathias Agopian13127d82013-03-05 17:47:11 -0800170 };
171
172 struct State {
173 Geometry active;
174 Geometry requested;
Robert Carrae060832016-11-28 10:51:00 -0800175 int32_t z;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800176
177 // The identifier of the layer stack this layer belongs to. A layer can
178 // only be associated to a single layer stack. A layer stack is a
179 // z-ordered group of layers which can be associated to one or more
180 // displays. Using the same layer stack on different displays is a way
181 // to achieve mirroring.
Mathias Agopian13127d82013-03-05 17:47:11 -0800182 uint32_t layerStack;
Fabien Sanglardf0c53d62017-03-03 18:58:50 -0800183
Mathias Agopian13127d82013-03-05 17:47:11 -0800184 uint8_t flags;
Dan Stoza7dde5992015-05-22 09:51:44 -0700185 uint8_t mask;
Mathias Agopian13127d82013-03-05 17:47:11 -0800186 uint8_t reserved[2];
187 int32_t sequence; // changes when visible regions can change
Dan Stoza7dde5992015-05-22 09:51:44 -0700188 bool modified;
189
Fabien Sanglard4ed383c2016-12-13 14:02:41 -0800190 // Crop is expressed in layer space coordinate.
Robert Carrb5d3d262016-03-25 15:08:13 -0700191 Rect crop;
Robert Carr99e27f02016-06-16 15:18:02 -0700192 Rect requestedCrop;
193
Fabien Sanglard4ed383c2016-12-13 14:02:41 -0800194 // finalCrop is expressed in display space coordinate.
Robert Carrb5d3d262016-03-25 15:08:13 -0700195 Rect finalCrop;
Robert Carr8d5227b2017-03-16 15:41:03 -0700196 Rect requestedFinalCrop;
Robert Carrb5d3d262016-03-25 15:08:13 -0700197
Robert Carr0d480722017-01-10 16:42:54 -0800198 // If set, defers this state update until the identified Layer
Dan Stoza7dde5992015-05-22 09:51:44 -0700199 // receives a frame with the given frameNumber
Robert Carr0d480722017-01-10 16:42:54 -0800200 wp<Layer> barrierLayer;
Dan Stoza7dde5992015-05-22 09:51:44 -0700201 uint64_t frameNumber;
202
Mathias Agopian2ca79392013-04-02 18:30:32 -0700203 // the transparentRegion hint is a bit special, it's latched only
204 // when we receive a buffer -- this is because it's "content"
205 // dependent.
206 Region activeTransparentRegion;
207 Region requestedTransparentRegion;
Courtney Goeltzenleuchterbb09b432016-11-30 13:51:28 -0700208 android_dataspace dataSpace;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500209
210 uint32_t appId;
211 uint32_t type;
Robert Carrdb66e622017-04-10 16:55:57 -0700212
213 // If non-null, a Surface this Surface's Z-order is interpreted relative to.
214 wp<Layer> zOrderRelativeOf;
215
216 // A list of surfaces whose Z-order is interpreted relative to ours.
217 SortedVector<wp<Layer>> zOrderRelatives;
chaviw13fdc492017-06-27 12:40:18 -0700218
219 half4 color;
Mathias Agopian13127d82013-03-05 17:47:11 -0800220 };
221
David Sodman41fdfc92017-11-06 16:09:56 -0800222 Layer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name, uint32_t w,
223 uint32_t h, uint32_t flags);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700224 virtual ~Layer();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800225
Chia-I Wuab0c3192017-08-01 11:29:00 -0700226 void setPrimaryDisplayOnly() { mPrimaryDisplayOnly = true; }
227
Robert Carr7bf247e2017-05-18 14:02:49 -0700228 // ------------------------------------------------------------------------
229 // Geometry setting functions.
230 //
231 // The following group of functions are used to specify the layers
232 // bounds, and the mapping of the texture on to those bounds. According
233 // to various settings changes to them may apply immediately, or be delayed until
234 // a pending resize is completed by the producer submitting a buffer. For example
235 // if we were to change the buffer size, and update the matrix ahead of the
236 // new buffer arriving, then we would be stretching the buffer to a different
237 // aspect before and after the buffer arriving, which probably isn't what we wanted.
238 //
239 // The first set of geometry functions are controlled by the scaling mode, described
240 // in window.h. The scaling mode may be set by the client, as it submits buffers.
241 // This value may be overriden through SurfaceControl, with setOverrideScalingMode.
242 //
243 // Put simply, if our scaling mode is SCALING_MODE_FREEZE, then
244 // matrix updates will not be applied while a resize is pending
245 // and the size and transform will remain in their previous state
246 // until a new buffer is submitted. If the scaling mode is another value
247 // then the old-buffer will immediately be scaled to the pending size
248 // and the new matrix will be immediately applied following this scaling
249 // transformation.
Robert Carr8d5227b2017-03-16 15:41:03 -0700250
Robert Carr7bf247e2017-05-18 14:02:49 -0700251 // Set the default buffer size for the assosciated Producer, in pixels. This is
252 // also the rendered size of the layer prior to any transformations. Parent
253 // or local matrix transformations will not affect the size of the buffer,
254 // but may affect it's on-screen size or clipping.
255 bool setSize(uint32_t w, uint32_t h);
256 // Set a 2x2 transformation matrix on the layer. This transform
257 // will be applied after parent transforms, but before any final
258 // producer specified transform.
259 bool setMatrix(const layer_state_t::matrix22_t& matrix);
260
261 // This second set of geometry attributes are controlled by
262 // setGeometryAppliesWithResize, and their default mode is to be
263 // immediate. If setGeometryAppliesWithResize is specified
264 // while a resize is pending, then update of these attributes will
265 // be delayed until the resize completes.
266
267 // setPosition operates in parent buffer space (pre parent-transform) or display
268 // space for top-level layers.
Robert Carr82364e32016-05-15 11:27:47 -0700269 bool setPosition(float x, float y, bool immediate);
Robert Carr7bf247e2017-05-18 14:02:49 -0700270 // Buffer space
Robert Carr8d5227b2017-03-16 15:41:03 -0700271 bool setCrop(const Rect& crop, bool immediate);
Robert Carr7bf247e2017-05-18 14:02:49 -0700272 // Parent buffer space/display space
Robert Carr8d5227b2017-03-16 15:41:03 -0700273 bool setFinalCrop(const Rect& crop, bool immediate);
274
Robert Carr7bf247e2017-05-18 14:02:49 -0700275 // TODO(b/38182121): Could we eliminate the various latching modes by
276 // using the layer hierarchy?
277 // -----------------------------------------------------------------------
Robert Carrae060832016-11-28 10:51:00 -0800278 bool setLayer(int32_t z);
Robert Carrdb66e622017-04-10 16:55:57 -0700279 bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
280
Dan Stoza9e56aa02015-11-02 13:00:03 -0800281 bool setAlpha(float alpha);
chaviw13fdc492017-06-27 12:40:18 -0700282 bool setColor(const half3& color);
Mathias Agopian13127d82013-03-05 17:47:11 -0800283 bool setTransparentRegionHint(const Region& transparent);
284 bool setFlags(uint8_t flags, uint8_t mask);
Mathias Agopian13127d82013-03-05 17:47:11 -0800285 bool setLayerStack(uint32_t layerStack);
Courtney Goeltzenleuchterbb09b432016-11-30 13:51:28 -0700286 bool setDataSpace(android_dataspace dataSpace);
Courtney Goeltzenleuchter532b2632017-05-05 16:34:38 -0600287 android_dataspace getDataSpace() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700288 uint32_t getLayerStack() const;
Robert Carr0d480722017-01-10 16:42:54 -0800289 void deferTransactionUntil(const sp<IBinder>& barrierHandle, uint64_t frameNumber);
290 void deferTransactionUntil(const sp<Layer>& barrierLayer, uint64_t frameNumber);
Robert Carrc3574f72016-03-24 12:19:32 -0700291 bool setOverrideScalingMode(int32_t overrideScalingMode);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500292 void setInfo(uint32_t type, uint32_t appId);
Robert Carr1db73f62016-12-21 12:58:51 -0800293 bool reparentChildren(const sp<IBinder>& layer);
chaviwf1961f72017-09-18 16:41:07 -0700294 bool reparent(const sp<IBinder>& newParentHandle);
Robert Carr9524cb32017-02-13 11:32:32 -0800295 bool detachChildren();
Mathias Agopian13127d82013-03-05 17:47:11 -0800296
Dan Stozaee44edd2015-03-23 15:50:23 -0700297 // If we have received a new buffer this frame, we will pass its surface
298 // damage down to hardware composer. Otherwise, we must send a region with
299 // one empty rect.
David Sodmaneb085e02017-10-05 18:49:04 -0700300 virtual void useSurfaceDamage() = 0;
301 virtual void useEmptyDamage() = 0;
Dan Stozaee44edd2015-03-23 15:50:23 -0700302
Mathias Agopian13127d82013-03-05 17:47:11 -0800303 uint32_t getTransactionFlags(uint32_t flags);
304 uint32_t setTransactionFlags(uint32_t flags);
305
Chia-I Wuab0c3192017-08-01 11:29:00 -0700306 bool belongsToDisplay(uint32_t layerStack, bool isPrimaryDisplay) const {
307 return getLayerStack() == layerStack && (!mPrimaryDisplayOnly || isPrimaryDisplay);
308 }
309
chaviwa76b2712017-09-20 12:02:26 -0700310 void computeGeometry(const RenderArea& renderArea, Mesh& mesh, bool useIdentityTransform) const;
Dan Stoza80d61162017-12-20 15:57:52 -0800311 FloatRect computeBounds(const Region& activeTransparentRegion) const;
312 FloatRect computeBounds() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800313
Pablo Ceballos40845df2016-01-25 17:41:15 -0800314 int32_t getSequence() const { return sequence; }
315
Mathias Agopian13127d82013-03-05 17:47:11 -0800316 // -----------------------------------------------------------------------
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700317 // Virtuals
David Sodman0c69cad2017-08-21 12:12:51 -0700318 virtual const char* getTypeId() const = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -0800319
Mathias Agopian13127d82013-03-05 17:47:11 -0800320 /*
321 * isOpaque - true if this surface is opaque
Andy McFadden4125a4f2014-01-29 17:17:11 -0800322 *
323 * This takes into account the buffer format (i.e. whether or not the
324 * pixel format includes an alpha channel) and the "opaque" flag set
325 * on the layer. It does not examine the current plane alpha value.
Mathias Agopian13127d82013-03-05 17:47:11 -0800326 */
David Sodman0c69cad2017-08-21 12:12:51 -0700327 virtual bool isOpaque(const Layer::State& s) const = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -0800328
329 /*
330 * isSecure - true if this surface is secure, that is if it prevents
331 * screenshots or VNC servers.
332 */
David Sodman0c69cad2017-08-21 12:12:51 -0700333 bool isSecure() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800334
335 /*
336 * isVisible - true if this layer is visible, false otherwise
337 */
David Sodman0c69cad2017-08-21 12:12:51 -0700338 virtual bool isVisible() const = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800339
Mathias Agopian13127d82013-03-05 17:47:11 -0800340 /*
Robert Carr1f0a16a2016-10-24 16:27:39 -0700341 * isHiddenByPolicy - true if this layer has been forced invisible.
342 * just because this is false, doesn't mean isVisible() is true.
343 * For example if this layer has no active buffer, it may not be hidden by
344 * policy, but it still can not be visible.
345 */
David Sodman0c69cad2017-08-21 12:12:51 -0700346 bool isHiddenByPolicy() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700347
348 /*
Mathias Agopian13127d82013-03-05 17:47:11 -0800349 * isFixedSize - true if content has a fixed size
350 */
David Sodman0c69cad2017-08-21 12:12:51 -0700351 virtual bool isFixedSize() const = 0;
Jamie Gennis582270d2011-08-17 18:19:00 -0700352
chaviw8b3871a2017-11-01 17:41:01 -0700353 bool isPendingRemoval() const { return mPendingRemoval; }
354
David Sodman41fdfc92017-11-06 16:09:56 -0800355 void writeToProto(LayerProto* layerInfo,
356 LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing);
chaviw1d044282017-09-27 12:19:28 -0700357
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700358protected:
359 /*
360 * onDraw - draws the surface.
361 */
chaviwa76b2712017-09-20 12:02:26 -0700362 virtual void onDraw(const RenderArea& renderArea, const Region& clip,
David Sodman0c69cad2017-08-21 12:12:51 -0700363 bool useIdentityTransform) const = 0;
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700364
365public:
David Sodmaneb085e02017-10-05 18:49:04 -0700366 virtual void setDefaultBufferSize(uint32_t w, uint32_t h) = 0;
367
Robert Carrae060832016-11-28 10:51:00 -0800368 void setGeometry(const sp<const DisplayDevice>& displayDevice, uint32_t z);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800369 void forceClientComposition(int32_t hwcId);
chaviwc9232ed2017-11-14 15:31:15 -0800370 bool getForceClientComposition(int32_t hwcId);
David Sodmaneb085e02017-10-05 18:49:04 -0700371 virtual void setPerFrameData(const sp<const DisplayDevice>& displayDevice) = 0;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800372
373 // callIntoHwc exists so we can update our local state and call
374 // acceptDisplayChanges without unnecessarily updating the device's state
David Sodman0c69cad2017-08-21 12:12:51 -0700375 void setCompositionType(int32_t hwcId, HWC2::Composition type, bool callIntoHwc = true);
Dan Stoza9e56aa02015-11-02 13:00:03 -0800376 HWC2::Composition getCompositionType(int32_t hwcId) const;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800377 void setClearClientTarget(int32_t hwcId, bool clear);
378 bool getClearClientTarget(int32_t hwcId) const;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800379 void updateCursorPosition(const sp<const DisplayDevice>& hw);
Riley Andrews03414a12014-07-01 14:22:59 -0700380
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700381 /*
382 * called after page-flip
383 */
David Sodmaneb085e02017-10-05 18:49:04 -0700384 virtual void onLayerDisplayed(const sp<Fence>& releaseFence);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700385
David Sodmaneb085e02017-10-05 18:49:04 -0700386 virtual void abandon() = 0;
387
388 virtual bool shouldPresentNow(const DispSync& dispSync) const = 0;
389 virtual void setTransformHint(uint32_t orientation) const = 0;
Dan Stoza6b9454d2014-11-07 16:00:59 -0800390
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700391 /*
392 * called before composition.
393 * returns true if the layer has pending updates.
394 */
David Sodman0c69cad2017-08-21 12:12:51 -0700395 virtual bool onPreComposition(nsecs_t refreshStartTime) = 0;
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700396
397 /*
Dan Stozae77c7662016-05-13 11:37:28 -0700398 * called after composition.
399 * returns true if the layer latched a new buffer this frame.
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700400 */
David Sodmaneb085e02017-10-05 18:49:04 -0700401 virtual bool onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
402 const std::shared_ptr<FenceTime>& presentFence,
403 const CompositorTiming& compositorTiming) = 0;
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700404
Dan Stoza9e56aa02015-11-02 13:00:03 -0800405 // If a buffer was replaced this frame, release the former buffer
David Sodman0c69cad2017-08-21 12:12:51 -0700406 virtual void releasePendingBuffer(nsecs_t dequeueReadyTime) = 0;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800407
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700408 /*
409 * draw - performs some global clipping optimizations
410 * and calls onDraw().
411 */
chaviwa76b2712017-09-20 12:02:26 -0700412 void draw(const RenderArea& renderArea, const Region& clip) const;
413 void draw(const RenderArea& renderArea, bool useIdentityTransform) const;
414 void draw(const RenderArea& renderArea) const;
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700415
416 /*
417 * doTransaction - process the transaction. This is a good place to figure
418 * out which attributes of the surface have changed.
419 */
420 uint32_t doTransaction(uint32_t transactionFlags);
421
422 /*
423 * setVisibleRegion - called to set the new visible region. This gives
424 * a chance to update the new visible region or record the fact it changed.
425 */
426 void setVisibleRegion(const Region& visibleRegion);
427
428 /*
429 * setCoveredRegion - called when the covered region changes. The covered
430 * region corresponds to any area of the surface that is covered
431 * (transparently or not) by another surface.
432 */
433 void setCoveredRegion(const Region& coveredRegion);
434
435 /*
436 * setVisibleNonTransparentRegion - called when the visible and
437 * non-transparent region changes.
438 */
David Sodman41fdfc92017-11-06 16:09:56 -0800439 void setVisibleNonTransparentRegion(const Region& visibleNonTransparentRegion);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700440
441 /*
Robert Carre5f4f692018-01-12 13:12:28 -0800442 * Clear the visible, covered, and non-transparent regions.
443 */
444 void clearVisibilityRegions();
445
446 /*
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700447 * latchBuffer - called each time the screen is redrawn and returns whether
448 * the visible regions need to be recomputed (this is a fairly heavy
449 * operation, so this should be set only if needed). Typically this is used
450 * to figure out if the content or size of a surface has changed.
451 */
David Sodman0c69cad2017-08-21 12:12:51 -0700452 virtual Region latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) = 0;
453 virtual bool isBufferLatched() const = 0;
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700454
David Sodman0c69cad2017-08-21 12:12:51 -0700455 bool isPotentialCursor() const { return mPotentialCursor; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800456 /*
Chia-I Wuc6657022017-08-15 11:18:17 -0700457 * called with the state lock from a binder thread when the layer is
458 * removed from the current list to the pending removal list
459 */
460 void onRemovedFromCurrentState();
461
462 /*
463 * called with the state lock from the main thread when the layer is
464 * removed from the pending removal list
Mathias Agopian13127d82013-03-05 17:47:11 -0800465 */
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700466 void onRemoved();
Mathias Agopian13127d82013-03-05 17:47:11 -0800467
Andy McFaddenbf974ab2012-12-04 16:51:15 -0800468 // Updates the transform hint in our SurfaceFlingerConsumer to match
Mathias Agopian84300952012-11-21 16:02:13 -0800469 // the current orientation of the display device.
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700470 void updateTransformHint(const sp<const DisplayDevice>& hw) const;
Andy McFadden69052052012-09-14 16:10:11 -0700471
Mathias Agopian13127d82013-03-05 17:47:11 -0800472 /*
473 * returns the rectangle that crops the content of the layer and scales it
474 * to the layer's size.
475 */
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700476 Rect getContentCrop() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800477
Eric Penner51c59cd2014-07-28 19:51:58 -0700478 /*
479 * Returns if a frame is queued.
480 */
David Sodman41fdfc92017-11-06 16:09:56 -0800481 bool hasQueuedFrame() const {
482 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
483 }
Eric Penner51c59cd2014-07-28 19:51:58 -0700484
Kalle Raitaa099a242017-01-11 11:17:29 -0800485 int32_t getQueuedFrameCount() const { return mQueuedFrames; }
486
Dan Stoza9e56aa02015-11-02 13:00:03 -0800487 // -----------------------------------------------------------------------
488
Steven Thomasb02664d2017-07-26 18:48:28 -0700489 bool createHwcLayer(HWComposer* hwc, int32_t hwcId);
Chia-I Wu83806892017-11-16 10:50:20 -0800490 bool destroyHwcLayer(int32_t hwcId);
Steven Thomasb02664d2017-07-26 18:48:28 -0700491 void destroyAllHwcLayers();
492
David Sodman6f65f3e2017-11-03 14:28:09 -0700493 bool hasHwcLayer(int32_t hwcId) {
494 return getBE().mHwcLayers.count(hwcId) > 0;
495 }
Dan Stoza9e56aa02015-11-02 13:00:03 -0800496
Steven Thomasb02664d2017-07-26 18:48:28 -0700497 HWC2::Layer* getHwcLayer(int32_t hwcId) {
David Sodman6f65f3e2017-11-03 14:28:09 -0700498 if (getBE().mHwcLayers.count(hwcId) == 0) {
Dan Stoza9e56aa02015-11-02 13:00:03 -0800499 return nullptr;
500 }
David Sodman6f65f3e2017-11-03 14:28:09 -0700501 return getBE().mHwcLayers[hwcId].layer;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800502 }
503
Mathias Agopian13127d82013-03-05 17:47:11 -0800504 // -----------------------------------------------------------------------
505
chaviwa76b2712017-09-20 12:02:26 -0700506 void clearWithOpenGL(const RenderArea& renderArea) const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800507 void setFiltering(bool filtering);
508 bool getFiltering() const;
509
Mathias Agopian13127d82013-03-05 17:47:11 -0800510
David Sodman41fdfc92017-11-06 16:09:56 -0800511 inline const State& getDrawingState() const { return mDrawingState; }
512 inline const State& getCurrentState() const { return mCurrentState; }
513 inline State& getCurrentState() { return mCurrentState; }
Mathias Agopian13127d82013-03-05 17:47:11 -0800514
Kalle Raitaa099a242017-01-11 11:17:29 -0800515 LayerDebugInfo getLayerDebugInfo() const;
Mathias Agopian13127d82013-03-05 17:47:11 -0800516
517 /* always call base class first */
Dan Stozae22aec72016-08-01 13:20:59 -0700518 static void miniDumpHeader(String8& result);
519 void miniDump(String8& result, int32_t hwcId) const;
Svetoslavd85084b2014-03-20 10:28:31 -0700520 void dumpFrameStats(String8& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700521 void dumpFrameEvents(String8& result);
Svetoslavd85084b2014-03-20 10:28:31 -0700522 void clearFrameStats();
Jamie Gennis6547ff42013-07-16 20:12:42 -0700523 void logFrameStats();
Svetoslavd85084b2014-03-20 10:28:31 -0700524 void getFrameStats(FrameStats* outStats) const;
Mathias Agopian1b5e1022010-04-20 17:55:49 -0700525
David Sodmaneb085e02017-10-05 18:49:04 -0700526 virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) = 0;
Dan Stozae77c7662016-05-13 11:37:28 -0700527
Brian Anderson5ea5e592016-12-01 16:54:33 -0800528 void onDisconnect();
Brian Anderson3890c392016-07-25 12:48:08 -0700529 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
David Sodman41fdfc92017-11-06 16:09:56 -0800530 FrameEventHistoryDelta* outDelta);
Pablo Ceballosce796e72016-02-04 19:10:51 -0800531
David Sodmaneb085e02017-10-05 18:49:04 -0700532 virtual bool getTransformToDisplayInverse() const = 0;
Robert Carr367c5682016-06-20 11:55:28 -0700533
Robert Carr1f0a16a2016-10-24 16:27:39 -0700534 Transform getTransform() const;
535
Robert Carr6452f122017-03-21 10:41:29 -0700536 // Returns the Alpha of the Surface, accounting for the Alpha
537 // of parent Surfaces in the hierarchy (alpha's will be multiplied
538 // down the hierarchy).
chaviw13fdc492017-06-27 12:40:18 -0700539 half getAlpha() const;
540 half4 getColor() const;
Robert Carr6452f122017-03-21 10:41:29 -0700541
Dan Stoza412903f2017-04-27 13:42:17 -0700542 void traverseInReverseZOrder(LayerVector::StateSet stateSet,
543 const LayerVector::Visitor& visitor);
544 void traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700545
chaviwa76b2712017-09-20 12:02:26 -0700546 void traverseChildrenInZOrder(LayerVector::StateSet stateSet,
547 const LayerVector::Visitor& visitor);
548
Chia-I Wu98f1c102017-05-30 14:54:08 -0700549 size_t getChildrenCount() const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700550 void addChild(const sp<Layer>& layer);
551 // Returns index if removed, or negative value otherwise
552 // for symmetry with Vector::remove
553 ssize_t removeChild(const sp<Layer>& layer);
Chia-I Wue41dbe62017-06-13 14:10:56 -0700554 sp<Layer> getParent() const { return mCurrentParent.promote(); }
Robert Carr1f0a16a2016-10-24 16:27:39 -0700555 bool hasParent() const { return getParent() != nullptr; }
Robert Carr1f0a16a2016-10-24 16:27:39 -0700556 Rect computeScreenBounds(bool reduceTransparentRegion = true) const;
557 bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
Robert Carr503c7042017-09-27 15:06:08 -0700558 bool setChildRelativeLayer(const sp<Layer>& childLayer,
559 const sp<IBinder>& relativeToHandle, int32_t relativeZ);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700560
561 // Copy the current list of children to the drawing state. Called by
562 // SurfaceFlinger to complete a transaction.
563 void commitChildList();
Robert Carr1f0a16a2016-10-24 16:27:39 -0700564 int32_t getZ() const;
David Sodman41fdfc92017-11-06 16:09:56 -0800565
Mathias Agopian13127d82013-03-05 17:47:11 -0800566protected:
567 // constant
568 sp<SurfaceFlinger> mFlinger;
Mathias Agopian13127d82013-03-05 17:47:11 -0800569 /*
570 * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer)
571 * is called.
572 */
573 class LayerCleaner {
574 sp<SurfaceFlinger> mFlinger;
575 wp<Layer> mLayer;
David Sodman41fdfc92017-11-06 16:09:56 -0800576
Mathias Agopian13127d82013-03-05 17:47:11 -0800577 protected:
Irvel468051e2016-06-13 16:44:44 -0700578 ~LayerCleaner() {
579 // destroy client resources
580 mFlinger->onLayerDestroyed(mLayer);
581 }
David Sodman41fdfc92017-11-06 16:09:56 -0800582
Mathias Agopian13127d82013-03-05 17:47:11 -0800583 public:
David Sodman41fdfc92017-11-06 16:09:56 -0800584 LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
585 : mFlinger(flinger), mLayer(layer) {}
Mathias Agopian13127d82013-03-05 17:47:11 -0800586 };
587
Irvel468051e2016-06-13 16:44:44 -0700588 virtual void onFirstRef();
589
Lloyd Pique4dccc412018-01-22 17:21:36 -0800590 friend class impl::SurfaceInterceptor;
David Sodmaneb085e02017-10-05 18:49:04 -0700591
Pablo Ceballos05289c22016-04-14 15:49:55 -0700592 void commitTransaction(const State& stateToCommit);
Mathias Agopian1eae0ee2013-06-05 16:59:15 -0700593
Mathias Agopian3330b202009-10-05 17:07:12 -0700594 uint32_t getEffectiveUsage(uint32_t usage) const;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700595
Dan Stoza5a423ea2017-02-16 14:10:39 -0800596 FloatRect computeCrop(const sp<const DisplayDevice>& hw) const;
David Sodman0c69cad2017-08-21 12:12:51 -0700597 // Compute the initial crop as specified by parent layers and the
598 // SurfaceControl for this layer. Does not include buffer crop from the
599 // IGraphicBufferProducer client, as that should not affect child clipping.
600 // Returns in screen space.
Robert Carr1f0a16a2016-10-24 16:27:39 -0700601 Rect computeInitialCrop(const sp<const DisplayDevice>& hw) const;
Mathias Agopian0aa758d2009-04-22 15:23:34 -0700602
Mathias Agopian13127d82013-03-05 17:47:11 -0800603 // drawing
David Sodman41fdfc92017-11-06 16:09:56 -0800604 void clearWithOpenGL(const RenderArea& renderArea, float r, float g, float b,
605 float alpha) const;
Dan Stozac5da2712016-07-20 15:38:12 -0700606
Robert Carr1f0a16a2016-10-24 16:27:39 -0700607 void setParent(const sp<Layer>& layer);
608
Robert Carr29abff82017-12-04 13:51:20 -0800609 LayerVector makeTraversalList(LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers);
Robert Carrdb66e622017-04-10 16:55:57 -0700610 void addZOrderRelative(const wp<Layer>& relative);
611 void removeZOrderRelative(const wp<Layer>& relative);
612
David Sodman41fdfc92017-11-06 16:09:56 -0800613 class SyncPoint {
Dan Stoza7dde5992015-05-22 09:51:44 -0700614 public:
David Sodman41fdfc92017-11-06 16:09:56 -0800615 explicit SyncPoint(uint64_t frameNumber)
616 : mFrameNumber(frameNumber), mFrameIsAvailable(false), mTransactionIsApplied(false) {}
Dan Stoza7dde5992015-05-22 09:51:44 -0700617
David Sodman41fdfc92017-11-06 16:09:56 -0800618 uint64_t getFrameNumber() const { return mFrameNumber; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700619
David Sodman41fdfc92017-11-06 16:09:56 -0800620 bool frameIsAvailable() const { return mFrameIsAvailable; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700621
David Sodman41fdfc92017-11-06 16:09:56 -0800622 void setFrameAvailable() { mFrameIsAvailable = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700623
David Sodman41fdfc92017-11-06 16:09:56 -0800624 bool transactionIsApplied() const { return mTransactionIsApplied; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700625
David Sodman41fdfc92017-11-06 16:09:56 -0800626 void setTransactionApplied() { mTransactionIsApplied = true; }
Dan Stoza7dde5992015-05-22 09:51:44 -0700627
628 private:
629 const uint64_t mFrameNumber;
630 std::atomic<bool> mFrameIsAvailable;
631 std::atomic<bool> mTransactionIsApplied;
632 };
633
Dan Stozacac35382016-01-27 12:21:06 -0800634 // SyncPoints which will be signaled when the correct frame is at the head
635 // of the queue and dropped after the frame has been latched. Protected by
636 // mLocalSyncPointMutex.
637 Mutex mLocalSyncPointMutex;
Dan Stoza7dde5992015-05-22 09:51:44 -0700638 std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
639
Dan Stozacac35382016-01-27 12:21:06 -0800640 // SyncPoints which will be signaled and then dropped when the transaction
641 // is applied
Dan Stoza7dde5992015-05-22 09:51:44 -0700642 std::list<std::shared_ptr<SyncPoint>> mRemoteSyncPoints;
643
Dan Stozacac35382016-01-27 12:21:06 -0800644 // Returns false if the relevant frame has already been latched
645 bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
Dan Stoza7dde5992015-05-22 09:51:44 -0700646
647 void pushPendingState();
Pablo Ceballos05289c22016-04-14 15:49:55 -0700648 void popPendingState(State* stateToCommit);
649 bool applyPendingStates(State* stateToCommit);
Robert Carrc3574f72016-03-24 12:19:32 -0700650
Robert Carr1f0a16a2016-10-24 16:27:39 -0700651 void clearSyncPoints();
652
Robert Carrc3574f72016-03-24 12:19:32 -0700653 // Returns mCurrentScaling mode (originating from the
654 // Client) or mOverrideScalingMode mode (originating from
655 // the Surface Controller) if set.
David Sodman0c69cad2017-08-21 12:12:51 -0700656 virtual uint32_t getEffectiveScalingMode() const = 0;
David Sodman41fdfc92017-11-06 16:09:56 -0800657
Dan Stoza7dde5992015-05-22 09:51:44 -0700658public:
Irvel468051e2016-06-13 16:44:44 -0700659 /*
660 * The layer handle is just a BBinder object passed to the client
661 * (remote process) -- we don't keep any reference on our side such that
662 * the dtor is called when the remote side let go of its reference.
663 *
664 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
665 * this layer when the handle is destroyed.
666 */
667 class Handle : public BBinder, public LayerCleaner {
David Sodman41fdfc92017-11-06 16:09:56 -0800668 public:
669 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
670 : LayerCleaner(flinger, layer), owner(layer) {}
Irvel468051e2016-06-13 16:44:44 -0700671
David Sodman41fdfc92017-11-06 16:09:56 -0800672 wp<Layer> owner;
Irvel468051e2016-06-13 16:44:44 -0700673 };
674
675 sp<IBinder> getHandle();
Irvel468051e2016-06-13 16:44:44 -0700676 const String8& getName() const;
David Sodman0c69cad2017-08-21 12:12:51 -0700677 virtual void notifyAvailableFrames() = 0;
678 virtual PixelFormat getPixelFormat() const = 0;
chaviw13fdc492017-06-27 12:40:18 -0700679 bool getPremultipledAlpha() const;
Igor Murashkina4a31492012-10-29 13:36:11 -0700680
David Sodman41fdfc92017-11-06 16:09:56 -0800681protected:
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700682 // -----------------------------------------------------------------------
Robert Carr29abff82017-12-04 13:51:20 -0800683 bool usingRelativeZ(LayerVector::StateSet stateSet);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700684
Mathias Agopian13127d82013-03-05 17:47:11 -0800685 bool mPremultipliedAlpha;
686 String8 mName;
David Sodman41fdfc92017-11-06 16:09:56 -0800687 String8 mTransactionName; // A cached version of "TX - " + mName for systraces
Mathias Agopian13127d82013-03-05 17:47:11 -0800688
Chia-I Wuab0c3192017-08-01 11:29:00 -0700689 bool mPrimaryDisplayOnly = false;
690
Mathias Agopian13127d82013-03-05 17:47:11 -0800691 // these are protected by an external lock
692 State mCurrentState;
693 State mDrawingState;
694 volatile int32_t mTransactionFlags;
Mathias Agopiand606de62010-05-10 20:06:11 -0700695
Dan Stoza7dde5992015-05-22 09:51:44 -0700696 // Accessed from main thread and binder threads
697 Mutex mPendingStateMutex;
698 Vector<State> mPendingStates;
699
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700700 // thread-safe
Mathias Agopiana67932f2011-04-20 14:20:59 -0700701 volatile int32_t mQueuedFrames;
David Sodman41fdfc92017-11-06 16:09:56 -0800702 volatile int32_t mSidebandStreamChanged; // used like an atomic boolean
Brian Andersond6927fb2016-07-23 23:37:30 -0700703
704 // Timestamp history for UIAutomation. Thread safe.
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800705 FrameTracker mFrameTracker;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700706
Brian Andersond6927fb2016-07-23 23:37:30 -0700707 // Timestamp history for the consumer to query.
708 // Accessed by both consumer and producer on main and binder threads.
709 Mutex mFrameEventHistoryMutex;
Brian Anderson3890c392016-07-25 12:48:08 -0700710 ConsumerFrameEventHistory mFrameEventHistory;
Brian Anderson3d4039d2016-09-23 16:31:30 -0700711 FenceTimeline mAcquireTimeline;
712 FenceTimeline mReleaseTimeline;
Brian Andersond6927fb2016-07-23 23:37:30 -0700713
Mathias Agopiana67932f2011-04-20 14:20:59 -0700714 // main thread
Mathias Agopiana9347642017-02-13 16:42:28 -0800715 int mActiveBufferSlot;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700716 sp<GraphicBuffer> mActiveBuffer;
Jesse Hall399184a2014-03-03 15:42:54 -0800717 sp<NativeHandle> mSidebandStream;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700718 Rect mCurrentCrop;
719 uint32_t mCurrentTransform;
Robert Carrc3574f72016-03-24 12:19:32 -0700720 // We encode unset as -1.
721 int32_t mOverrideScalingMode;
Mathias Agopiana67932f2011-04-20 14:20:59 -0700722 bool mCurrentOpacity;
Dan Stozacac35382016-01-27 12:21:06 -0800723 std::atomic<uint64_t> mCurrentFrameNumber;
Jamie Gennise8696a42012-01-15 18:54:57 -0800724 bool mFrameLatencyNeeded;
Mathias Agopian13127d82013-03-05 17:47:11 -0800725 // Whether filtering is forced on or not
726 bool mFiltering;
727 // Whether filtering is needed b/c of the drawingstate
728 bool mNeedsFiltering;
David Sodman0c69cad2017-08-21 12:12:51 -0700729
chaviw8b3871a2017-11-01 17:41:01 -0700730 bool mPendingRemoval = false;
731
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700732 // page-flip thread (currently main thread)
Glenn Kasten16f04532011-01-19 15:27:27 -0800733 bool mProtectedByApp; // application requires protected path to external sink
Mathias Agopian13127d82013-03-05 17:47:11 -0800734
735 // protected by mLock
736 mutable Mutex mLock;
David Sodman0c69cad2017-08-21 12:12:51 -0700737
Mathias Agopian13127d82013-03-05 17:47:11 -0800738 const wp<Client> mClientRef;
Riley Andrews03414a12014-07-01 14:22:59 -0700739
740 // This layer can be a cursor on some displays.
741 bool mPotentialCursor;
Dan Stoza6b9454d2014-11-07 16:00:59 -0800742
743 // Local copy of the queued contents of the incoming BufferQueue
744 mutable Mutex mQueueItemLock;
Dan Stozaa4650a52015-05-12 12:56:16 -0700745 Condition mQueueItemCondition;
Dan Stoza6b9454d2014-11-07 16:00:59 -0800746 Vector<BufferItem> mQueueItems;
Dan Stozacac35382016-01-27 12:21:06 -0800747 std::atomic<uint64_t> mLastFrameNumberReceived;
Pablo Ceballosff95aab2016-01-13 17:09:58 -0800748 bool mAutoRefresh;
Robert Carr7bf247e2017-05-18 14:02:49 -0700749 bool mFreezeGeometryUpdates;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700750
751 // Child list about to be committed/used for editing.
752 LayerVector mCurrentChildren;
753 // Child list used for rendering.
754 LayerVector mDrawingChildren;
755
Chia-I Wue41dbe62017-06-13 14:10:56 -0700756 wp<Layer> mCurrentParent;
757 wp<Layer> mDrawingParent;
David Sodman9eeae692017-11-02 10:53:32 -0700758
759 mutable LayerBE mBE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800760};
761
762// ---------------------------------------------------------------------------
763
764}; // namespace android
765
766#endif // ANDROID_LAYER_H