1 2 /* 3 * Copyright (C) 2007 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #pragma once 19 20 #include <compositionengine/LayerFE.h> 21 #include <gui/BufferQueue.h> 22 #include <gui/ISurfaceComposerClient.h> 23 #include <gui/LayerState.h> 24 #include <input/InputWindow.h> 25 #include <layerproto/LayerProtoHeader.h> 26 #include <math/vec4.h> 27 #include <renderengine/Mesh.h> 28 #include <renderengine/Texture.h> 29 #include <sys/types.h> 30 #include <ui/BlurRegion.h> 31 #include <ui/FloatRect.h> 32 #include <ui/FrameStats.h> 33 #include <ui/GraphicBuffer.h> 34 #include <ui/PixelFormat.h> 35 #include <ui/Region.h> 36 #include <ui/StretchEffect.h> 37 #include <ui/Transform.h> 38 #include <utils/RefBase.h> 39 #include <utils/Timers.h> 40 41 #include <chrono> 42 #include <cstdint> 43 #include <list> 44 #include <optional> 45 #include <vector> 46 47 #include "Client.h" 48 #include "ClientCache.h" 49 #include "DisplayHardware/ComposerHal.h" 50 #include "DisplayHardware/HWComposer.h" 51 #include "Fps.h" 52 #include "FrameTracker.h" 53 #include "LayerVector.h" 54 #include "MonitoredProducer.h" 55 #include "RenderArea.h" 56 #include "Scheduler/LayerInfo.h" 57 #include "Scheduler/Seamlessness.h" 58 #include "SurfaceFlinger.h" 59 #include "SurfaceTracing.h" 60 #include "TransactionCallbackInvoker.h" 61 62 using namespace android::surfaceflinger; 63 64 namespace android { 65 66 class Client; 67 class Colorizer; 68 class DisplayDevice; 69 class GraphicBuffer; 70 class SurfaceFlinger; 71 class LayerDebugInfo; 72 73 namespace compositionengine { 74 class OutputLayer; 75 struct LayerFECompositionState; 76 } 77 78 namespace impl { 79 class SurfaceInterceptor; 80 } 81 82 namespace frametimeline { 83 class SurfaceFrame; 84 } // namespace frametimeline 85 86 struct LayerCreationArgs { 87 LayerCreationArgs(SurfaceFlinger*, sp<Client>, std::string name, uint32_t w, uint32_t h, 88 uint32_t flags, LayerMetadata); 89 90 SurfaceFlinger* flinger; 91 const sp<Client> client; 92 std::string name; 93 uint32_t w; 94 uint32_t h; 95 uint32_t flags; 96 LayerMetadata metadata; 97 98 pid_t callingPid; 99 uid_t callingUid; 100 uint32_t textureName; 101 }; 102 103 class Layer : public virtual RefBase, compositionengine::LayerFE { 104 static std::atomic<int32_t> sSequence; 105 // The following constants represent priority of the window. SF uses this information when 106 // deciding which window has a priority when deciding about the refresh rate of the screen. 107 // Priority 0 is considered the highest priority. -1 means that the priority is unset. 108 static constexpr int32_t PRIORITY_UNSET = -1; 109 // Windows that are in focus and voted for the preferred mode ID 110 static constexpr int32_t PRIORITY_FOCUSED_WITH_MODE = 0; 111 // // Windows that are in focus, but have not requested a specific mode ID. 112 static constexpr int32_t PRIORITY_FOCUSED_WITHOUT_MODE = 1; 113 // Windows that are not in focus, but voted for a specific mode ID. 114 static constexpr int32_t PRIORITY_NOT_FOCUSED_WITH_MODE = 2; 115 116 public: 117 enum { // flags for doTransaction() 118 eDontUpdateGeometryState = 0x00000001, 119 eVisibleRegion = 0x00000002, 120 eInputInfoChanged = 0x00000004 121 }; 122 123 struct Geometry { 124 uint32_t w; 125 uint32_t h; 126 ui::Transform transform; 127 128 inline bool operator==(const Geometry& rhs) const { 129 return (w == rhs.w && h == rhs.h) && (transform.tx() == rhs.transform.tx()) && 130 (transform.ty() == rhs.transform.ty()); 131 } 132 inline bool operator!=(const Geometry& rhs) const { return !operator==(rhs); } 133 }; 134 135 struct RoundedCornerState { 136 RoundedCornerState() = default; RoundedCornerStateRoundedCornerState137 RoundedCornerState(FloatRect cropRect, float radius) 138 : cropRect(cropRect), radius(radius) {} 139 140 // Rounded rectangle in local layer coordinate space. 141 FloatRect cropRect = FloatRect(); 142 // Radius of the rounded rectangle. 143 float radius = 0.0f; 144 }; 145 146 using FrameRate = scheduler::LayerInfo::FrameRate; 147 using FrameRateCompatibility = scheduler::LayerInfo::FrameRateCompatibility; 148 149 struct State { 150 Geometry active_legacy; 151 Geometry requested_legacy; 152 int32_t z; 153 154 // The identifier of the layer stack this layer belongs to. A layer can 155 // only be associated to a single layer stack. A layer stack is a 156 // z-ordered group of layers which can be associated to one or more 157 // displays. Using the same layer stack on different displays is a way 158 // to achieve mirroring. 159 uint32_t layerStack; 160 161 uint32_t flags; 162 uint8_t reserved[2]; 163 int32_t sequence; // changes when visible regions can change 164 bool modified; 165 166 // Crop is expressed in layer space coordinate. 167 Rect crop; 168 Rect requestedCrop; 169 170 // the transparentRegion hint is a bit special, it's latched only 171 // when we receive a buffer -- this is because it's "content" 172 // dependent. 173 Region activeTransparentRegion_legacy; 174 Region requestedTransparentRegion_legacy; 175 176 LayerMetadata metadata; 177 178 // If non-null, a Surface this Surface's Z-order is interpreted relative to. 179 wp<Layer> zOrderRelativeOf; 180 bool isRelativeOf{false}; 181 182 // A list of surfaces whose Z-order is interpreted relative to ours. 183 SortedVector<wp<Layer>> zOrderRelatives; 184 185 half4 color; 186 float cornerRadius; 187 int backgroundBlurRadius; 188 189 InputWindowInfo inputInfo; 190 wp<Layer> touchableRegionCrop; 191 192 // dataspace is only used by BufferStateLayer and EffectLayer 193 ui::Dataspace dataspace; 194 195 // The fields below this point are only used by BufferStateLayer 196 uint64_t frameNumber; 197 uint32_t width; 198 uint32_t height; 199 ui::Transform transform; 200 201 uint32_t bufferTransform; 202 bool transformToDisplayInverse; 203 204 Region transparentRegionHint; 205 206 std::shared_ptr<renderengine::ExternalTexture> buffer; 207 client_cache_t clientCacheId; 208 sp<Fence> acquireFence; 209 std::shared_ptr<FenceTime> acquireFenceTime; 210 HdrMetadata hdrMetadata; 211 Region surfaceDamageRegion; 212 int32_t api; 213 214 sp<NativeHandle> sidebandStream; 215 mat4 colorTransform; 216 bool hasColorTransform; 217 218 // pointer to background color layer that, if set, appears below the buffer state layer 219 // and the buffer state layer's children. Z order will be set to 220 // INT_MIN 221 sp<Layer> bgColorLayer; 222 223 // The deque of callback handles for this frame. The back of the deque contains the most 224 // recent callback handle. 225 std::deque<sp<CallbackHandle>> callbackHandles; 226 bool colorSpaceAgnostic; 227 nsecs_t desiredPresentTime = 0; 228 bool isAutoTimestamp = true; 229 230 // Length of the cast shadow. If the radius is > 0, a shadow of length shadowRadius will 231 // be rendered around the layer. 232 float shadowRadius; 233 234 // Layer regions that are made of custom materials, like frosted glass 235 std::vector<BlurRegion> blurRegions; 236 237 // Priority of the layer assigned by Window Manager. 238 int32_t frameRateSelectionPriority; 239 240 FrameRate frameRate; 241 242 // The combined frame rate of parents / children of this layer 243 FrameRate frameRateForLayerTree; 244 245 // Set by window manager indicating the layer and all its children are 246 // in a different orientation than the display. The hint suggests that 247 // the graphic producers should receive a transform hint as if the 248 // display was in this orientation. When the display changes to match 249 // the layer orientation, the graphic producer may not need to allocate 250 // a buffer of a different size. ui::Transform::ROT_INVALID means the 251 // a fixed transform hint is not set. 252 ui::Transform::RotationFlags fixedTransformHint; 253 254 // The vsync info that was used to start the transaction 255 FrameTimelineInfo frameTimelineInfo; 256 257 // When the transaction was posted 258 nsecs_t postTime; 259 260 sp<ITransactionCompletedListener> releaseBufferListener; 261 // SurfaceFrame that tracks the timeline of Transactions that contain a Buffer. Only one 262 // such SurfaceFrame exists because only one buffer can be presented on the layer per vsync. 263 // If multiple buffers are queued, the prior ones will be dropped, along with the 264 // SurfaceFrame that's tracking them. 265 std::shared_ptr<frametimeline::SurfaceFrame> bufferSurfaceFrameTX; 266 // A map of token(frametimelineVsyncId) to the SurfaceFrame that's tracking a transaction 267 // that contains the token. Only one SurfaceFrame exisits for transactions that share the 268 // same token, unless they are presented in different vsyncs. 269 std::unordered_map<int64_t, std::shared_ptr<frametimeline::SurfaceFrame>> 270 bufferlessSurfaceFramesTX; 271 // An arbitrary threshold for the number of BufferlessSurfaceFrames in the state. Used to 272 // trigger a warning if the number of SurfaceFrames crosses the threshold. 273 static constexpr uint32_t kStateSurfaceFramesThreshold = 25; 274 275 // Stretch effect to apply to this layer 276 StretchEffect stretchEffect; 277 278 // Whether or not this layer is a trusted overlay for input 279 bool isTrustedOverlay; 280 281 Rect bufferCrop; 282 Rect destinationFrame; 283 }; 284 285 /* 286 * Trivial class, used to ensure that mFlinger->onLayerDestroyed(mLayer) 287 * is called. 288 */ 289 class LayerCleaner { 290 sp<SurfaceFlinger> mFlinger; 291 sp<Layer> mLayer; 292 293 protected: ~LayerCleaner()294 ~LayerCleaner() { 295 // destroy client resources 296 mFlinger->onHandleDestroyed(mLayer); 297 } 298 299 public: LayerCleaner(const sp<SurfaceFlinger> & flinger,const sp<Layer> & layer)300 LayerCleaner(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 301 : mFlinger(flinger), mLayer(layer) {} 302 }; 303 304 /* 305 * The layer handle is just a BBinder object passed to the client 306 * (remote process) -- we don't keep any reference on our side such that 307 * the dtor is called when the remote side let go of its reference. 308 * 309 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for 310 * this layer when the handle is destroyed. 311 */ 312 class Handle : public BBinder, public LayerCleaner { 313 public: Handle(const sp<SurfaceFlinger> & flinger,const sp<Layer> & layer)314 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer) 315 : LayerCleaner(flinger, layer), owner(layer) {} 316 317 wp<Layer> owner; 318 }; 319 320 explicit Layer(const LayerCreationArgs& args); 321 virtual ~Layer(); 322 323 static bool isLayerFocusedBasedOnPriority(int32_t priority); 324 static void miniDumpHeader(std::string& result); 325 static std::string frameRateCompatibilityString(FrameRateCompatibility compatibility); 326 327 // Provide unique string for each class type in the Layer hierarchy 328 virtual const char* getType() const = 0; 329 330 // true if this layer is visible, false otherwise 331 virtual bool isVisible() const = 0; 332 333 virtual sp<Layer> createClone() = 0; 334 335 // Geometry setting functions. 336 // 337 // The following group of functions are used to specify the layers 338 // bounds, and the mapping of the texture on to those bounds. According 339 // to various settings changes to them may apply immediately, or be delayed until 340 // a pending resize is completed by the producer submitting a buffer. For example 341 // if we were to change the buffer size, and update the matrix ahead of the 342 // new buffer arriving, then we would be stretching the buffer to a different 343 // aspect before and after the buffer arriving, which probably isn't what we wanted. 344 // 345 // The first set of geometry functions are controlled by the scaling mode, described 346 // in window.h. The scaling mode may be set by the client, as it submits buffers. 347 // 348 // Put simply, if our scaling mode is SCALING_MODE_FREEZE, then 349 // matrix updates will not be applied while a resize is pending 350 // and the size and transform will remain in their previous state 351 // until a new buffer is submitted. If the scaling mode is another value 352 // then the old-buffer will immediately be scaled to the pending size 353 // and the new matrix will be immediately applied following this scaling 354 // transformation. 355 356 // Set the default buffer size for the assosciated Producer, in pixels. This is 357 // also the rendered size of the layer prior to any transformations. Parent 358 // or local matrix transformations will not affect the size of the buffer, 359 // but may affect it's on-screen size or clipping. 360 virtual bool setSize(uint32_t w, uint32_t h); 361 // Set a 2x2 transformation matrix on the layer. This transform 362 // will be applied after parent transforms, but before any final 363 // producer specified transform. 364 virtual bool setMatrix(const layer_state_t::matrix22_t& matrix, 365 bool allowNonRectPreservingTransforms); 366 367 // This second set of geometry attributes are controlled by 368 // setGeometryAppliesWithResize, and their default mode is to be 369 // immediate. If setGeometryAppliesWithResize is specified 370 // while a resize is pending, then update of these attributes will 371 // be delayed until the resize completes. 372 373 // setPosition operates in parent buffer space (pre parent-transform) or display 374 // space for top-level layers. 375 virtual bool setPosition(float x, float y); 376 // Buffer space 377 virtual bool setCrop(const Rect& crop); 378 379 // TODO(b/38182121): Could we eliminate the various latching modes by 380 // using the layer hierarchy? 381 // ----------------------------------------------------------------------- 382 virtual bool setLayer(int32_t z); 383 virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ); 384 385 virtual bool setAlpha(float alpha); setColor(const half3 &)386 virtual bool setColor(const half3& /*color*/) { return false; }; 387 388 // Set rounded corner radius for this layer and its children. 389 // 390 // We only support 1 radius per layer in the hierarchy, where parent layers have precedence. 391 // The shape of the rounded corner rectangle is specified by the crop rectangle of the layer 392 // from which we inferred the rounded corner radius. 393 virtual bool setCornerRadius(float cornerRadius); 394 // When non-zero, everything below this layer will be blurred by backgroundBlurRadius, which 395 // is specified in pixels. 396 virtual bool setBackgroundBlurRadius(int backgroundBlurRadius); 397 virtual bool setBlurRegions(const std::vector<BlurRegion>& effectRegions); 398 virtual bool setTransparentRegionHint(const Region& transparent); 399 virtual bool setTrustedOverlay(bool); 400 virtual bool setFlags(uint32_t flags, uint32_t mask); 401 virtual bool setLayerStack(uint32_t layerStack); 402 virtual uint32_t getLayerStack() const; 403 virtual bool setMetadata(const LayerMetadata& data); 404 virtual void setChildrenDrawingParent(const sp<Layer>&); 405 virtual bool reparent(const sp<IBinder>& newParentHandle); 406 virtual bool setColorTransform(const mat4& matrix); 407 virtual mat4 getColorTransform() const; 408 virtual bool hasColorTransform() const; isColorSpaceAgnostic()409 virtual bool isColorSpaceAgnostic() const { return mDrawingState.colorSpaceAgnostic; } 410 411 // Used only to set BufferStateLayer state setTransform(uint32_t)412 virtual bool setTransform(uint32_t /*transform*/) { return false; }; setTransformToDisplayInverse(bool)413 virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; }; setBuffer(const std::shared_ptr<renderengine::ExternalTexture> &,const sp<Fence> &,nsecs_t,nsecs_t,bool,const client_cache_t &,uint64_t,std::optional<nsecs_t>,const FrameTimelineInfo &,const sp<ITransactionCompletedListener> &)414 virtual bool setBuffer(const std::shared_ptr<renderengine::ExternalTexture>& /*buffer*/, 415 const sp<Fence>& /*acquireFence*/, nsecs_t /*postTime*/, 416 nsecs_t /*desiredPresentTime*/, bool /*isAutoTimestamp*/, 417 const client_cache_t& /*clientCacheId*/, uint64_t /* frameNumber */, 418 std::optional<nsecs_t> /* dequeueTime */, 419 const FrameTimelineInfo& /*info*/, 420 const sp<ITransactionCompletedListener>& /* releaseBufferListener */) { 421 return false; 422 }; setAcquireFence(const sp<Fence> &)423 virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; }; setDataspace(ui::Dataspace)424 virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; }; setHdrMetadata(const HdrMetadata &)425 virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; }; setSurfaceDamageRegion(const Region &)426 virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) { return false; }; setApi(int32_t)427 virtual bool setApi(int32_t /*api*/) { return false; }; setSidebandStream(const sp<NativeHandle> &)428 virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; }; setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>> &)429 virtual bool setTransactionCompletedListeners( 430 const std::vector<sp<CallbackHandle>>& /*handles*/) { 431 return false; 432 }; addFrameEvent(const sp<Fence> &,nsecs_t,nsecs_t)433 virtual bool addFrameEvent(const sp<Fence>& /*acquireFence*/, nsecs_t /*postedTime*/, 434 nsecs_t /*requestedPresentTime*/) { 435 return false; 436 } 437 virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace); 438 virtual bool setColorSpaceAgnostic(const bool agnostic); 439 virtual bool setFrameRateSelectionPriority(int32_t priority); 440 virtual bool setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint); setAutoRefresh(bool)441 virtual void setAutoRefresh(bool /* autoRefresh */) {} 442 // If the variable is not set on the layer, it traverses up the tree to inherit the frame 443 // rate priority from its parent. 444 virtual int32_t getFrameRateSelectionPriority() const; getDataSpace()445 virtual ui::Dataspace getDataSpace() const { return ui::Dataspace::UNKNOWN; } 446 447 virtual sp<compositionengine::LayerFE> getCompositionEngineLayerFE() const; 448 virtual compositionengine::LayerFECompositionState* editCompositionState(); 449 450 // If we have received a new buffer this frame, we will pass its surface 451 // damage down to hardware composer. Otherwise, we must send a region with 452 // one empty rect. useSurfaceDamage()453 virtual void useSurfaceDamage() {} useEmptyDamage()454 virtual void useEmptyDamage() {} 455 Region getVisibleRegion(const DisplayDevice*) const; 456 457 /* 458 * isOpaque - true if this surface is opaque 459 * 460 * This takes into account the buffer format (i.e. whether or not the 461 * pixel format includes an alpha channel) and the "opaque" flag set 462 * on the layer. It does not examine the current plane alpha value. 463 */ isOpaque(const Layer::State &)464 virtual bool isOpaque(const Layer::State&) const { return false; } 465 466 /* 467 * Returns whether this layer can receive input. 468 */ 469 virtual bool canReceiveInput() const; 470 471 /* 472 * isProtected - true if the layer may contain protected contents in the 473 * GRALLOC_USAGE_PROTECTED sense. 474 */ isProtected()475 virtual bool isProtected() const { return false; } 476 477 /* 478 * isFixedSize - true if content has a fixed size 479 */ isFixedSize()480 virtual bool isFixedSize() const { return true; } 481 482 /* 483 * usesSourceCrop - true if content should use a source crop 484 */ usesSourceCrop()485 virtual bool usesSourceCrop() const { return false; } 486 487 // Most layers aren't created from the main thread, and therefore need to 488 // grab the SF state lock to access HWC, but ContainerLayer does, so we need 489 // to avoid grabbing the lock again to avoid deadlock isCreatedFromMainThread()490 virtual bool isCreatedFromMainThread() const { return false; } 491 getActiveWidth(const Layer::State & s)492 uint32_t getActiveWidth(const Layer::State& s) const { return s.width; } getActiveHeight(const Layer::State & s)493 uint32_t getActiveHeight(const Layer::State& s) const { return s.height; } getActiveTransform(const Layer::State & s)494 ui::Transform getActiveTransform(const Layer::State& s) const { return s.transform; } getActiveTransparentRegion(const Layer::State & s)495 virtual Region getActiveTransparentRegion(const Layer::State& s) const { 496 return s.activeTransparentRegion_legacy; 497 } getCrop(const Layer::State & s)498 virtual Rect getCrop(const Layer::State& s) const { return s.crop; } needsFiltering(const DisplayDevice *)499 virtual bool needsFiltering(const DisplayDevice*) const { return false; } 500 501 // True if this layer requires filtering 502 // This method is distinct from needsFiltering() in how the filter 503 // requirement is computed. needsFiltering() compares displayFrame and crop, 504 // where as this method transforms the displayFrame to layer-stack space 505 // first. This method should be used if there is no physical display to 506 // project onto when taking screenshots, as the filtering requirements are 507 // different. 508 // If the parent transform needs to be undone when capturing the layer, then 509 // the inverse parent transform is also required. needsFilteringForScreenshots(const DisplayDevice *,const ui::Transform &)510 virtual bool needsFilteringForScreenshots(const DisplayDevice*, const ui::Transform&) const { 511 return false; 512 } 513 updateCloneBufferInfo()514 virtual void updateCloneBufferInfo(){}; 515 setDefaultBufferSize(uint32_t,uint32_t)516 virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {} 517 isHdrY410()518 virtual bool isHdrY410() const { return false; } 519 shouldPresentNow(nsecs_t)520 virtual bool shouldPresentNow(nsecs_t /*expectedPresentTime*/) const { return false; } 521 getHeadFrameNumber(nsecs_t)522 virtual uint64_t getHeadFrameNumber(nsecs_t /* expectedPresentTime */) const { return 0; } 523 524 /* 525 * called after composition. 526 * returns true if the layer latched a new buffer this frame. 527 */ onPostComposition(const DisplayDevice *,const std::shared_ptr<FenceTime> &,const std::shared_ptr<FenceTime> &,const CompositorTiming &)528 virtual bool onPostComposition(const DisplayDevice*, 529 const std::shared_ptr<FenceTime>& /*glDoneFence*/, 530 const std::shared_ptr<FenceTime>& /*presentFence*/, 531 const CompositorTiming&) { 532 return false; 533 } 534 535 // If a buffer was replaced this frame, release the former buffer releasePendingBuffer(nsecs_t)536 virtual void releasePendingBuffer(nsecs_t /*dequeueReadyTime*/) { } 537 finalizeFrameEventHistory(const std::shared_ptr<FenceTime> &,const CompositorTiming &)538 virtual void finalizeFrameEventHistory(const std::shared_ptr<FenceTime>& /*glDoneFence*/, 539 const CompositorTiming& /*compositorTiming*/) {} 540 541 /* 542 * latchBuffer - called each time the screen is redrawn and returns whether 543 * the visible regions need to be recomputed (this is a fairly heavy 544 * operation, so this should be set only if needed). Typically this is used 545 * to figure out if the content or size of a surface has changed. 546 */ latchBuffer(bool &,nsecs_t,nsecs_t)547 virtual bool latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/, 548 nsecs_t /*expectedPresentTime*/) { 549 return false; 550 } 551 isBufferLatched()552 virtual bool isBufferLatched() const { return false; } 553 latchAndReleaseBuffer()554 virtual void latchAndReleaseBuffer() {} 555 556 /* 557 * returns the rectangle that crops the content of the layer and scales it 558 * to the layer's size. 559 */ getBufferCrop()560 virtual Rect getBufferCrop() const { return Rect(); } 561 562 /* 563 * Returns the transform applied to the buffer. 564 */ getBufferTransform()565 virtual uint32_t getBufferTransform() const { return 0; } 566 getBuffer()567 virtual sp<GraphicBuffer> getBuffer() const { return nullptr; } 568 getTransformHint()569 virtual ui::Transform::RotationFlags getTransformHint() const { return ui::Transform::ROT_0; } 570 571 /* 572 * Returns if a frame is ready 573 */ hasReadyFrame()574 virtual bool hasReadyFrame() const { return false; } 575 getQueuedFrameCount()576 virtual int32_t getQueuedFrameCount() const { return 0; } 577 578 /** 579 * Returns active buffer size in the correct orientation. Buffer size is determined by undoing 580 * any buffer transformations. If the layer has no buffer then return INVALID_RECT. 581 */ getBufferSize(const Layer::State &)582 virtual Rect getBufferSize(const Layer::State&) const { return Rect::INVALID_RECT; } 583 584 /** 585 * Returns the source bounds. If the bounds are not defined, it is inferred from the 586 * buffer size. Failing that, the bounds are determined from the passed in parent bounds. 587 * For the root layer, this is the display viewport size. 588 */ computeSourceBounds(const FloatRect & parentBounds)589 virtual FloatRect computeSourceBounds(const FloatRect& parentBounds) const { 590 return parentBounds; 591 } 592 virtual FrameRate getFrameRateForLayerTree() const; 593 getOccupancyHistory(bool)594 virtual std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool /*forceFlush*/) { 595 return {}; 596 } 597 getTransformToDisplayInverse()598 virtual bool getTransformToDisplayInverse() const { return false; } 599 600 // Returns how rounded corners should be drawn for this layer. 601 // This will traverse the hierarchy until it reaches its root, finding topmost rounded 602 // corner definition and converting it into current layer's coordinates. 603 // As of now, only 1 corner radius per display list is supported. Subsequent ones will be 604 // ignored. 605 virtual RoundedCornerState getRoundedCornerState() const; 606 hasRoundedCorners()607 bool hasRoundedCorners() const override { return getRoundedCornerState().radius > .0f; } 608 getPixelFormat()609 virtual PixelFormat getPixelFormat() const { return PIXEL_FORMAT_NONE; } 610 /** 611 * Return whether this layer needs an input info. For most layer types 612 * this is only true if they explicitly set an input-info but BufferLayer 613 * overrides this so we can generate input-info for Buffered layers that don't 614 * have them (for input occlusion detection checks). 615 */ needsInputInfo()616 virtual bool needsInputInfo() const { return hasInputInfo(); } 617 618 // Implements RefBase. 619 void onFirstRef() override; 620 621 // implements compositionengine::LayerFE 622 const compositionengine::LayerFECompositionState* getCompositionState() const override; 623 bool onPreComposition(nsecs_t) override; 624 void prepareCompositionState(compositionengine::LayerFE::StateSubset subset) override; 625 std::vector<compositionengine::LayerFE::LayerSettings> prepareClientCompositionList( 626 compositionengine::LayerFE::ClientCompositionTargetSettings&) override; 627 void onLayerDisplayed(const sp<Fence>& releaseFence) override; 628 const char* getDebugName() const override; 629 630 bool setShadowRadius(float shadowRadius); 631 632 // Before color management is introduced, contents on Android have to be 633 // desaturated in order to match what they appears like visually. 634 // With color management, these contents will appear desaturated, thus 635 // needed to be saturated so that they match what they are designed for 636 // visually. 637 bool isLegacyDataSpace() const; 638 getTransactionFlags()639 uint32_t getTransactionFlags() const { return mTransactionFlags; } 640 uint32_t getTransactionFlags(uint32_t flags); 641 uint32_t setTransactionFlags(uint32_t flags); 642 643 // Deprecated, please use compositionengine::Output::belongsInOutput() 644 // instead. 645 // TODO(lpique): Move the remaining callers (screencap) to the new function. belongsToDisplay(uint32_t layerStack)646 bool belongsToDisplay(uint32_t layerStack) const { return getLayerStack() == layerStack; } 647 648 FloatRect getBounds(const Region& activeTransparentRegion) const; 649 FloatRect getBounds() const; 650 651 // Compute bounds for the layer and cache the results. 652 void computeBounds(FloatRect parentBounds, ui::Transform parentTransform, float shadowRadius); 653 getSequence()654 int32_t getSequence() const override { return sequence; } 655 656 // For tracing. 657 // TODO: Replace with raw buffer id from buffer metadata when that becomes available. 658 // GraphicBuffer::getId() does not provide a reliable global identifier. Since the traces 659 // creates its tracks by buffer id and has no way of associating a buffer back to the process 660 // that created it, the current implementation is only sufficient for cases where a buffer is 661 // only used within a single layer. getCurrentBufferId()662 uint64_t getCurrentBufferId() const { return getBuffer() ? getBuffer()->getId() : 0; } 663 664 /* 665 * isSecure - true if this surface is secure, that is if it prevents 666 * screenshots or VNC servers. A surface can be set to be secure by the 667 * application, being secure doesn't mean the surface has DRM contents. 668 */ 669 bool isSecure() const; 670 671 /* 672 * isHiddenByPolicy - true if this layer has been forced invisible. 673 * just because this is false, doesn't mean isVisible() is true. 674 * For example if this layer has no active buffer, it may not be hidden by 675 * policy, but it still can not be visible. 676 */ 677 bool isHiddenByPolicy() const; 678 679 bool isRemovedFromCurrentState() const; 680 681 LayerProto* writeToProto(LayersProto& layersProto, uint32_t traceFlags, const DisplayDevice*); 682 683 // Write states that are modified by the main thread. This includes drawing 684 // state as well as buffer data. This should be called in the main or tracing 685 // thread. 686 void writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags, const DisplayDevice*); 687 // Write drawing or current state. If writing current state, the caller should hold the 688 // external mStateLock. If writing drawing state, this function should be called on the 689 // main or tracing thread. 690 void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet, 691 uint32_t traceFlags = SurfaceTracing::TRACE_ALL); 692 getWindowType()693 InputWindowInfo::Type getWindowType() const { return mWindowType; } 694 695 bool getPrimaryDisplayOnly() const; 696 697 void updateMirrorInfo(); 698 699 /* 700 * doTransaction - process the transaction. This is a good place to figure 701 * out which attributes of the surface have changed. 702 */ 703 virtual uint32_t doTransaction(uint32_t transactionFlags); 704 705 /* 706 * Remove relative z for the layer if its relative parent is not part of the 707 * provided layer tree. 708 */ 709 void removeRelativeZ(const std::vector<Layer*>& layersInTree); 710 711 /* 712 * Remove from current state and mark for removal. 713 */ 714 void removeFromCurrentState(); 715 716 /* 717 * called with the state lock from a binder thread when the layer is 718 * removed from the current list to the pending removal list 719 */ 720 void onRemovedFromCurrentState(); 721 722 /* 723 * Called when the layer is added back to the current state list. 724 */ 725 void addToCurrentState(); 726 727 /* 728 * Sets display transform hint on BufferLayerConsumer. 729 */ 730 void updateTransformHint(ui::Transform::RotationFlags); 731 getDrawingState()732 inline const State& getDrawingState() const { return mDrawingState; } getDrawingState()733 inline State& getDrawingState() { return mDrawingState; } 734 735 LayerDebugInfo getLayerDebugInfo(const DisplayDevice*) const; 736 737 void miniDump(std::string& result, const DisplayDevice&) const; 738 void dumpFrameStats(std::string& result) const; 739 void dumpFrameEvents(std::string& result); 740 void dumpCallingUidPid(std::string& result) const; 741 void clearFrameStats(); 742 void logFrameStats(); 743 void getFrameStats(FrameStats* outStats) const; 744 void onDisconnect(); 745 void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry, 746 FrameEventHistoryDelta* outDelta); 747 748 ui::Transform getTransform() const; 749 750 // Returns the Alpha of the Surface, accounting for the Alpha 751 // of parent Surfaces in the hierarchy (alpha's will be multiplied 752 // down the hierarchy). 753 half getAlpha() const; 754 half4 getColor() const; 755 int32_t getBackgroundBlurRadius() const; drawShadows()756 bool drawShadows() const { return mEffectiveShadowRadius > 0.f; }; 757 758 // Returns the transform hint set by Window Manager on the layer or one of its parents. 759 // This traverses the current state because the data is needed when creating 760 // the layer(off drawing thread) and the hint should be available before the producer 761 // is ready to acquire a buffer. 762 ui::Transform::RotationFlags getFixedTransformHint() const; 763 764 /** 765 * Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder 766 * which will not emit children who have relativeZOrder to another layer, this method 767 * just directly emits all children. It also emits them in no particular order. 768 * So this method is not suitable for graphical operations, as it doesn't represent 769 * the scene state, but it's also more efficient than traverseInZOrder and so useful for 770 * book-keeping. 771 */ 772 void traverse(LayerVector::StateSet, const LayerVector::Visitor&); 773 void traverseInReverseZOrder(LayerVector::StateSet, const LayerVector::Visitor&); 774 void traverseInZOrder(LayerVector::StateSet, const LayerVector::Visitor&); 775 776 /** 777 * Traverse only children in z order, ignoring relative layers that are not children of the 778 * parent. 779 */ 780 void traverseChildrenInZOrder(LayerVector::StateSet, const LayerVector::Visitor&); 781 782 size_t getChildrenCount() const; 783 784 // ONLY CALL THIS FROM THE LAYER DTOR! 785 // See b/141111965. We need to add current children to offscreen layers in 786 // the layer dtor so as not to dangle layers. Since the layer has not 787 // committed its transaction when the layer is destroyed, we must add 788 // current children. This is safe in the dtor as we will no longer update 789 // the current state, but should not be called anywhere else! getCurrentChildren()790 LayerVector& getCurrentChildren() { return mCurrentChildren; } 791 792 void addChild(const sp<Layer>&); 793 // Returns index if removed, or negative value otherwise 794 // for symmetry with Vector::remove 795 ssize_t removeChild(const sp<Layer>& layer); getParent()796 sp<Layer> getParent() const { return mCurrentParent.promote(); } 797 798 // Should be called with the surfaceflinger statelock held isAtRoot()799 bool isAtRoot() const { return mIsAtRoot; } setIsAtRoot(bool isAtRoot)800 void setIsAtRoot(bool isAtRoot) { mIsAtRoot = isAtRoot; } 801 hasParent()802 bool hasParent() const { return getParent() != nullptr; } 803 Rect getScreenBounds(bool reduceTransparentRegion = true) const; 804 bool setChildLayer(const sp<Layer>& childLayer, int32_t z); 805 bool setChildRelativeLayer(const sp<Layer>& childLayer, 806 const sp<IBinder>& relativeToHandle, int32_t relativeZ); 807 808 // Copy the current list of children to the drawing state. Called by 809 // SurfaceFlinger to complete a transaction. 810 void commitChildList(); 811 int32_t getZ(LayerVector::StateSet) const; 812 813 /** 814 * Returns the cropped buffer size or the layer crop if the layer has no buffer. Return 815 * INVALID_RECT if the layer has no buffer and no crop. 816 * A layer with an invalid buffer size and no crop is considered to be boundless. The layer 817 * bounds are constrained by its parent bounds. 818 */ 819 Rect getCroppedBufferSize(const Layer::State& s) const; 820 821 bool setFrameRate(FrameRate); 822 setFrameTimelineInfoForBuffer(const FrameTimelineInfo &)823 virtual void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& /*info*/) {} 824 void setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info, nsecs_t postTime); 825 void setFrameTimelineVsyncForBufferlessTransaction(const FrameTimelineInfo& info, 826 nsecs_t postTime); 827 828 void addSurfaceFrameDroppedForBuffer( 829 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame); 830 void addSurfaceFramePresentedForBuffer( 831 std::shared_ptr<frametimeline::SurfaceFrame>& surfaceFrame, nsecs_t acquireFenceTime, 832 nsecs_t currentLatchTime); 833 834 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForTransaction( 835 const FrameTimelineInfo& info, nsecs_t postTime); 836 std::shared_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForBuffer( 837 const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName); 838 839 // Creates a new handle each time, so we only expect 840 // this to be called once. 841 sp<IBinder> getHandle(); getName()842 const std::string& getName() const { return mName; } 843 bool getPremultipledAlpha() const; 844 void setInputInfo(const InputWindowInfo& info); 845 846 InputWindowInfo fillInputInfo(const sp<DisplayDevice>& display); 847 /** 848 * Returns whether this layer has an explicitly set input-info. 849 */ 850 bool hasInputInfo() const; 851 852 // Sets the parent's gameMode for this layer and all its children. Parent's gameMode is applied 853 // only to layers that do not have the GAME_MODE_METADATA set by WMShell. Any layer(along with 854 // its children) that has the metadata set will use the gameMode from the metadata. 855 void setGameModeForTree(int32_t parentGameMode); setGameMode(int32_t gameMode)856 void setGameMode(int32_t gameMode) { mGameMode = gameMode; }; getGameMode()857 int32_t getGameMode() const { return mGameMode; } 858 getOwnerUid()859 virtual uid_t getOwnerUid() const { return mOwnerUid; } 860 getOwnerPid()861 pid_t getOwnerPid() { return mOwnerPid; } 862 863 // This layer is not a clone, but it's the parent to the cloned hierarchy. The 864 // variable mClonedChild represents the top layer that will be cloned so this 865 // layer will be the parent of mClonedChild. 866 // The layers in the cloned hierarchy will match the lifetime of the real layers. That is 867 // if the real layer is destroyed, then the clone layer will also be destroyed. 868 sp<Layer> mClonedChild; 869 bool mHadClonedChild = false; 870 void setClonedChild(const sp<Layer>& mClonedChild); 871 872 mutable bool contentDirty{false}; 873 Region surfaceDamageRegion; 874 875 // Layer serial number. This gives layers an explicit ordering, so we 876 // have a stable sort order when their layer stack and Z-order are 877 // the same. 878 int32_t sequence{sSequence++}; 879 880 bool mPendingHWCDestroy{false}; 881 backpressureEnabled()882 bool backpressureEnabled() { return mDrawingState.flags & layer_state_t::eEnableBackpressure; } 883 884 bool setStretchEffect(const StretchEffect& effect); 885 StretchEffect getStretchEffect() const; 886 setBufferCrop(const Rect &)887 virtual bool setBufferCrop(const Rect& /* bufferCrop */) { return false; } setDestinationFrame(const Rect &)888 virtual bool setDestinationFrame(const Rect& /* destinationFrame */) { return false; } getPendingBufferCounter()889 virtual std::atomic<int32_t>* getPendingBufferCounter() { return nullptr; } getPendingBufferCounterName()890 virtual std::string getPendingBufferCounterName() { return ""; } updateGeometry()891 virtual bool updateGeometry() { return false; } 892 893 protected: 894 friend class impl::SurfaceInterceptor; 895 896 // For unit tests 897 friend class TestableSurfaceFlinger; 898 friend class FpsReporterTest; 899 friend class RefreshRateSelectionTest; 900 friend class SetFrameRateTest; 901 friend class TransactionFrameTracerTest; 902 friend class TransactionSurfaceFrameTest; 903 904 virtual void setInitialValuesForClone(const sp<Layer>& clonedFrom); 905 virtual std::optional<compositionengine::LayerFE::LayerSettings> prepareClientComposition( 906 compositionengine::LayerFE::ClientCompositionTargetSettings&); 907 virtual void preparePerFrameCompositionState(); 908 virtual void commitTransaction(State& stateToCommit); onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame> &)909 virtual void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&) {} 910 911 // Returns mCurrentScaling mode (originating from the 912 // Client) or mOverrideScalingMode mode (originating from 913 // the Surface Controller) if set. getEffectiveScalingMode()914 virtual uint32_t getEffectiveScalingMode() const { return 0; } 915 916 sp<compositionengine::LayerFE> asLayerFE() const; getClonedFrom()917 sp<Layer> getClonedFrom() { return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr; } isClone()918 bool isClone() { return mClonedFrom != nullptr; } isClonedFromAlive()919 bool isClonedFromAlive() { return getClonedFrom() != nullptr; } 920 921 void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap); 922 void updateClonedChildren(const sp<Layer>& mirrorRoot, 923 std::map<sp<Layer>, sp<Layer>>& clonedLayersMap); 924 void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap); 925 void addChildToDrawing(const sp<Layer>&); 926 void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap); 927 928 // Modifies the passed in layer settings to clear the contents. If the blackout flag is set, 929 // the settings clears the content with a solid black fill. 930 void prepareClearClientComposition(LayerFE::LayerSettings&, bool blackout) const; 931 void prepareShadowClientComposition(LayerFE::LayerSettings& caster, const Rect& layerStackRect); 932 933 void prepareBasicGeometryCompositionState(); 934 void prepareGeometryCompositionState(); 935 void prepareCursorCompositionState(); 936 937 uint32_t getEffectiveUsage(uint32_t usage) const; 938 939 /** 940 * Setup rounded corners coordinates of this layer, taking into account the layer bounds and 941 * crop coordinates, transforming them into layer space. 942 */ 943 void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const; 944 void setParent(const sp<Layer>&); 945 LayerVector makeTraversalList(LayerVector::StateSet, bool* outSkipRelativeZUsers); 946 void addZOrderRelative(const wp<Layer>& relative); 947 void removeZOrderRelative(const wp<Layer>& relative); 948 compositionengine::OutputLayer* findOutputLayerForDisplay(const DisplayDevice*) const; 949 bool usingRelativeZ(LayerVector::StateSet) const; 950 951 virtual ui::Transform getInputTransform() const; 952 virtual Rect getInputBounds() const; 953 954 // constant 955 sp<SurfaceFlinger> mFlinger; 956 957 bool mPremultipliedAlpha{true}; 958 const std::string mName; 959 const std::string mTransactionName{"TX - " + mName}; 960 961 // These are only accessed by the main thread or the tracing thread. 962 State mDrawingState; 963 964 uint32_t mTransactionFlags{0}; 965 // Updated in doTransaction, used to track the last sequence number we 966 // committed. Currently this is really only used for updating visible 967 // regions. 968 int32_t mLastCommittedTxSequence = -1; 969 970 // Timestamp history for UIAutomation. Thread safe. 971 FrameTracker mFrameTracker; 972 973 // Timestamp history for the consumer to query. 974 // Accessed by both consumer and producer on main and binder threads. 975 Mutex mFrameEventHistoryMutex; 976 ConsumerFrameEventHistory mFrameEventHistory; 977 FenceTimeline mAcquireTimeline; 978 FenceTimeline mReleaseTimeline; 979 980 // main thread 981 sp<NativeHandle> mSidebandStream; 982 // False if the buffer and its contents have been previously used for GPU 983 // composition, true otherwise. 984 bool mIsActiveBufferUpdatedForGpu = true; 985 986 // We encode unset as -1. 987 std::atomic<uint64_t> mCurrentFrameNumber{0}; 988 // Whether filtering is needed b/c of the drawingstate 989 bool mNeedsFiltering{false}; 990 991 std::atomic<bool> mRemovedFromDrawingState{false}; 992 993 // page-flip thread (currently main thread) 994 bool mProtectedByApp{false}; // application requires protected path to external sink 995 996 // protected by mLock 997 mutable Mutex mLock; 998 999 const wp<Client> mClientRef; 1000 1001 // This layer can be a cursor on some displays. 1002 bool mPotentialCursor{false}; 1003 1004 LayerVector mCurrentChildren{LayerVector::StateSet::Current}; 1005 LayerVector mDrawingChildren{LayerVector::StateSet::Drawing}; 1006 1007 wp<Layer> mCurrentParent; 1008 wp<Layer> mDrawingParent; 1009 1010 // Window types from WindowManager.LayoutParams 1011 const InputWindowInfo::Type mWindowType; 1012 1013 // The owner of the layer. If created from a non system process, it will be the calling uid. 1014 // If created from a system process, the value can be passed in. 1015 uid_t mOwnerUid; 1016 1017 // The owner pid of the layer. If created from a non system process, it will be the calling pid. 1018 // If created from a system process, the value can be passed in. 1019 pid_t mOwnerPid; 1020 1021 // Keeps track of the time SF latched the last buffer from this layer. 1022 // Used in buffer stuffing analysis in FrameTimeline. 1023 nsecs_t mLastLatchTime = 0; 1024 1025 mutable bool mDrawingStateModified = false; 1026 1027 private: setTransformHint(ui::Transform::RotationFlags)1028 virtual void setTransformHint(ui::Transform::RotationFlags) {} 1029 1030 // Returns true if the layer can draw shadows on its border. canDrawShadows()1031 virtual bool canDrawShadows() const { return true; } 1032 1033 Hwc2::IComposerClient::Composition getCompositionType(const DisplayDevice&) const; 1034 1035 /** 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 */ 1039 std::vector<Layer*> getLayersInTree(LayerVector::StateSet); 1040 /** 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, 1045 LayerVector::StateSet, const LayerVector::Visitor&); 1046 LayerVector makeChildrenTraversalList(LayerVector::StateSet, 1047 const std::vector<Layer*>& layersInTree); 1048 1049 void updateTreeHasFrameRateVote(); 1050 bool propagateFrameRateForLayerTree(FrameRate parentFrameRate, bool* transactionNeeded); 1051 bool setFrameRateForLayerTree(FrameRate); 1052 void setZOrderRelativeOf(const wp<Layer>& relativeOf); 1053 bool isTrustedOverlay() const; 1054 1055 // Find the root of the cloned hierarchy, this means the first non cloned parent. 1056 // This will return null if first non cloned parent is not found. 1057 sp<Layer> getClonedRoot(); 1058 1059 // Finds the top most layer in the hierarchy. This will find the root Layer where the parent is 1060 // null. 1061 sp<Layer> getRootLayer(); 1062 1063 // Fills in the touch occlusion mode of the first parent (including this layer) that 1064 // hasInputInfo() or no-op if no such parent is found. 1065 void fillTouchOcclusionMode(InputWindowInfo& info); 1066 1067 // Fills in the frame and transform info for the InputWindowInfo 1068 void fillInputFrameInfo(InputWindowInfo& info, const ui::Transform& toPhysicalDisplay); 1069 1070 // Cached properties computed from drawing state 1071 // Effective transform taking into account parent transforms and any parent scaling, which is 1072 // a transform from the current layer coordinate space to display(screen) coordinate space. 1073 ui::Transform mEffectiveTransform; 1074 1075 // Bounds of the layer before any transformation is applied and before it has been cropped 1076 // by its parents. 1077 FloatRect mSourceBounds; 1078 1079 // Bounds of the layer in layer space. This is the mSourceBounds cropped by its layer crop and 1080 // its parent bounds. 1081 FloatRect mBounds; 1082 1083 // Layer bounds in screen space. 1084 FloatRect mScreenBounds; 1085 1086 bool mGetHandleCalled = false; 1087 1088 // Tracks the process and user id of the caller when creating this layer 1089 // to help debugging. 1090 pid_t mCallingPid; 1091 uid_t mCallingUid; 1092 1093 // The current layer is a clone of mClonedFrom. This means that this layer will update it's 1094 // properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers, 1095 // this layer will update it's buffer. When mClonedFrom updates it's drawing state, children, 1096 // and relatives, this layer will update as well. 1097 wp<Layer> mClonedFrom; 1098 1099 // The inherited shadow radius after taking into account the layer hierarchy. This is the 1100 // final shadow radius for this layer. If a shadow is specified for a layer, then effective 1101 // shadow radius is the set shadow radius, otherwise its the parent's shadow radius. 1102 float mEffectiveShadowRadius = 0.f; 1103 1104 // Game mode for the layer. Set by WindowManagerShell, game mode is used in 1105 // metrics(SurfaceFlingerStats). 1106 int32_t mGameMode = 0; 1107 1108 // A list of regions on this layer that should have blurs. 1109 const std::vector<BlurRegion> getBlurRegions() const; 1110 1111 bool mIsAtRoot = false; 1112 }; 1113 1114 std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate); 1115 1116 } // namespace android 1117