blob: fa38dd70cb46033f9439e7b43b3844fd130e7f32 [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 Laskowski718f9602019-11-09 20:01:35 -080017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
Peiyong Linefefaac2018-08-17 12:27:51 -070019#include <memory>
Dominik Laskowski075d3172018-05-24 15:50:06 -070020#include <optional>
Peiyong Linefefaac2018-08-17 12:27:51 -070021#include <string>
Peiyong Lin136fbbc2018-04-17 15:09:44 -070022#include <unordered_map>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080023
Alec Mourif6fd29e2018-11-17 04:56:41 +000024#include <android/native_window.h>
Dan Stoza9e56aa02015-11-02 13:00:03 -080025#include <binder/IBinder.h>
Chia-I Wuf2aa3112018-08-27 14:54:37 -070026#include <gui/LayerState.h>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070027#include <hardware/hwcomposer_defs.h>
Peiyong Linefefaac2018-08-17 12:27:51 -070028#include <math/mat4.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080029#include <renderengine/RenderEngine.h>
Alec Mourif6fd29e2018-11-17 04:56:41 +000030#include <system/window.h>
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080031#include <ui/DisplayState.h>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070032#include <ui/GraphicTypes.h>
Peiyong Linfb069302018-04-25 14:34:31 -070033#include <ui/HdrCapabilities.h>
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070034#include <ui/Region.h>
Peiyong Linefefaac2018-08-17 12:27:51 -070035#include <ui/Transform.h>
Alec Mouri8d4f90a2018-11-14 22:33:24 +000036#include <utils/Mutex.h>
Alec Mouri0a9c7b82018-11-16 13:05:25 -080037#include <utils/RefBase.h>
Mathias Agopian86303202012-07-24 22:46:10 -070038#include <utils/Timers.h>
39
Dominik Laskowski075d3172018-05-24 15:50:06 -070040#include "DisplayHardware/DisplayIdentification.h"
Lloyd Pique688abd42019-02-15 15:42:24 -080041#include "DisplayHardware/PowerAdvisor.h"
chaviwa76b2712017-09-20 12:02:26 -070042#include "RenderArea.h"
Ady Abraham2139f732019-11-13 18:56:40 -080043#include "Scheduler/HwcStrongTypes.h"
Mathias Agopianf4358632012-08-22 17:16:19 -070044
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080045namespace android {
46
Dan Stoza9e56aa02015-11-02 13:00:03 -080047class Fence;
Lloyd Pique2eef1d22018-09-18 21:30:04 -070048class HWComposer;
Jesse Hall9e663de2013-08-16 14:28:37 -070049class IGraphicBufferProducer;
Mathias Agopian13127d82013-03-05 17:47:11 -080050class Layer;
Mathias Agopian86303202012-07-24 22:46:10 -070051class SurfaceFlinger;
Lloyd Pique2eef1d22018-09-18 21:30:04 -070052
David Sodmanfb95bcc2017-12-22 15:45:30 -080053struct CompositionInfo;
Lloyd Pique2eef1d22018-09-18 21:30:04 -070054struct DisplayDeviceCreationArgs;
55struct DisplayInfo;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080056
Lloyd Pique45a165a2018-10-19 11:54:47 -070057namespace compositionengine {
58class Display;
Lloyd Pique542307f2018-10-19 13:24:08 -070059class DisplaySurface;
Lloyd Pique45a165a2018-10-19 11:54:47 -070060} // namespace compositionengine
61
62class DisplayDevice : public LightRefBase<DisplayDevice> {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080063public:
Peiyong Linfb069302018-04-25 14:34:31 -070064 constexpr static float sDefaultMinLumiance = 0.0;
65 constexpr static float sDefaultMaxLumiance = 500.0;
66
Lloyd Pique2eef1d22018-09-18 21:30:04 -070067 explicit DisplayDevice(DisplayDeviceCreationArgs&& args);
Lloyd Pique45a165a2018-10-19 11:54:47 -070068 virtual ~DisplayDevice();
69
70 std::shared_ptr<compositionengine::Display> getCompositionDisplay() const {
71 return mCompositionDisplay;
72 }
Mathias Agopian92a979a2012-08-02 18:32:23 -070073
Dominik Laskowski075d3172018-05-24 15:50:06 -070074 bool isVirtual() const { return mIsVirtual; }
75 bool isPrimary() const { return mIsPrimary; }
Mathias Agopian92a979a2012-08-02 18:32:23 -070076
Jamie Gennisdd3cb842012-10-19 18:19:11 -070077 // isSecure indicates whether this display can be trusted to display
78 // secure surfaces.
Lloyd Pique45a165a2018-10-19 11:54:47 -070079 bool isSecure() const;
Jamie Gennisdd3cb842012-10-19 18:19:11 -070080
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080081 int getWidth() const;
82 int getHeight() const;
83 ui::Size getSize() const { return {getWidth(), getHeight()}; }
Mathias Agopian3eb38cb2012-04-03 22:09:52 -070084
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080085 void setLayerStack(ui::LayerStack);
86 void setDisplaySize(int width, int height);
Dominik Laskowski718f9602019-11-09 20:01:35 -080087 void setProjection(ui::Rotation orientation, Rect viewport, Rect frame);
88
89 ui::Rotation getPhysicalOrientation() const { return mPhysicalOrientation; }
90 ui::Rotation getOrientation() const { return mOrientation; }
91
92 static ui::Transform::RotationFlags getPrimaryDisplayRotationFlags();
93
Lloyd Pique32cbe282018-10-19 13:09:22 -070094 const ui::Transform& getTransform() const;
95 const Rect& getViewport() const;
96 const Rect& getFrame() const;
97 const Rect& getScissor() const;
98 bool needsFiltering() const;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080099 ui::LayerStack getLayerStack() const;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700100
Lloyd Pique45a165a2018-10-19 11:54:47 -0700101 const std::optional<DisplayId>& getId() const;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700102 const wp<IBinder>& getDisplayToken() const { return mDisplayToken; }
Dominik Laskowskie9774092018-12-11 10:04:24 -0800103 int32_t getSequenceId() const { return mSequenceId; }
Mathias Agopian87baae12012-07-31 12:38:26 -0700104
Lloyd Pique32cbe282018-10-19 13:09:22 -0700105 const Region& getUndefinedRegion() const;
106
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700107 int32_t getSupportedPerFrameMetadata() const;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700108
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700109 bool hasWideColorGamut() const;
Peiyong Lin136fbbc2018-04-17 15:09:44 -0700110 // Whether h/w composer has native support for specific HDR type.
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700111 bool hasHDR10PlusSupport() const;
112 bool hasHDR10Support() const;
113 bool hasHLGSupport() const;
114 bool hasDolbyVisionSupport() const;
Chia-I Wube02ec02018-05-18 10:59:36 -0700115
Peiyong Linfb069302018-04-25 14:34:31 -0700116 // The returned HdrCapabilities is the combination of HDR capabilities from
117 // hardware composer and RenderEngine. When the DisplayDevice supports wide
118 // color gamut, RenderEngine is able to simulate HDR support in Display P3
119 // color space for both PQ and HLG HDR contents. The minimum and maximum
120 // luminance will be set to sDefaultMinLumiance and sDefaultMaxLumiance
121 // respectively if hardware composer doesn't return meaningful values.
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700122 const HdrCapabilities& getHdrCapabilities() const;
Jesse Hall38efe862013-04-06 23:12:29 -0700123
Chia-I Wube02ec02018-05-18 10:59:36 -0700124 // Return true if intent is supported by the display.
125 bool hasRenderIntent(ui::RenderIntent intent) const;
Peiyong Lin136fbbc2018-04-17 15:09:44 -0700126
Lloyd Pique32cbe282018-10-19 13:09:22 -0700127 const Rect& getBounds() const;
128 const Rect& bounds() const { return getBounds(); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800129
Dominik Laskowskibf170d92018-04-19 15:08:05 -0700130 void setDisplayName(const std::string& displayName);
131 const std::string& getDisplayName() const { return mDisplayName; }
Andy McFadden8dfa92f2012-09-17 18:27:17 -0700132
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700133 /* ------------------------------------------------------------------------
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700134 * Display power mode management.
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700135 */
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700136 int getPowerMode() const;
137 void setPowerMode(int mode);
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700138 bool isPoweredOn() const;
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700139
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800140 ui::Dataspace getCompositionDataSpace() const;
Michael Wright28f24d02016-07-12 13:30:53 -0700141
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700142 /* ------------------------------------------------------------------------
143 * Display active config management.
144 */
Ady Abraham2139f732019-11-13 18:56:40 -0800145 HwcConfigIndexType getActiveConfig() const;
146 void setActiveConfig(HwcConfigIndexType mode);
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700147
Jesse Hall02d86562013-03-25 14:43:23 -0700148 // release HWC resources (if any) for removable displays
Lloyd Pique45a165a2018-10-19 11:54:47 -0700149 void disconnect();
Jesse Hall02d86562013-03-25 14:43:23 -0700150
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700151 /* ------------------------------------------------------------------------
152 * Debugging
153 */
154 uint32_t getPageFlipCount() const;
Dominik Laskowski9b17b2c22018-11-01 14:49:03 -0700155 std::string getDebugName() const;
Yiwei Zhang5434a782018-12-05 18:06:32 -0800156 void dump(std::string& result) const;
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700157
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800158private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700159 const sp<SurfaceFlinger> mFlinger;
160 const wp<IBinder> mDisplayToken;
Dominik Laskowskie9774092018-12-11 10:04:24 -0800161 const int32_t mSequenceId;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800162 const bool mIsVirtual;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700163
Lloyd Pique45a165a2018-10-19 11:54:47 -0700164 const std::shared_ptr<compositionengine::Display> mCompositionDisplay;
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700165
Lloyd Pique31cb2942018-10-19 17:23:03 -0700166 std::string mDisplayName;
Mathias Agopian03e40722012-04-26 16:11:59 -0700167
Dominik Laskowski718f9602019-11-09 20:01:35 -0800168 const ui::Rotation mPhysicalOrientation;
169 ui::Rotation mOrientation = ui::ROTATION_0;
Mathias Agopiand3ee2312012-08-02 14:01:42 -0700170
Dominik Laskowski718f9602019-11-09 20:01:35 -0800171 static ui::Transform::RotationFlags sPrimaryDisplayRotationFlags;
Mathias Agopianda8d0a52012-09-04 15:05:38 -0700172
Dominik Laskowski718f9602019-11-09 20:01:35 -0800173 int mPowerMode = HWC_POWER_MODE_OFF;
Ady Abraham2139f732019-11-13 18:56:40 -0800174 HwcConfigIndexType mActiveConfig;
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600175
Dominik Laskowski075d3172018-05-24 15:50:06 -0700176 // TODO(b/74619554): Remove special cases for primary display.
177 const bool mIsPrimary;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800178};
179
Irvelffc9efc2016-07-27 15:16:37 -0700180struct DisplayDeviceState {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700181 bool isVirtual() const { return !displayId.has_value(); }
Irvelffc9efc2016-07-27 15:16:37 -0700182
Dominik Laskowski663bd282018-04-19 15:26:54 -0700183 int32_t sequenceId = sNextSequenceId++;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700184 std::optional<DisplayId> displayId;
Irvelffc9efc2016-07-27 15:16:37 -0700185 sp<IGraphicBufferProducer> surface;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800186 ui::LayerStack layerStack = ui::NO_LAYER_STACK;
Irvelffc9efc2016-07-27 15:16:37 -0700187 Rect viewport;
188 Rect frame;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800189 ui::Rotation orientation = ui::ROTATION_0;
Irvelffc9efc2016-07-27 15:16:37 -0700190 uint32_t width = 0;
191 uint32_t height = 0;
Dominik Laskowskibf170d92018-04-19 15:08:05 -0700192 std::string displayName;
Irvelffc9efc2016-07-27 15:16:37 -0700193 bool isSecure = false;
Dominik Laskowski663bd282018-04-19 15:26:54 -0700194
195private:
196 static std::atomic<int32_t> sNextSequenceId;
Irvelffc9efc2016-07-27 15:16:37 -0700197};
198
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700199struct DisplayDeviceCreationArgs {
200 // We use a constructor to ensure some of the values are set, without
201 // assuming a default value.
202 DisplayDeviceCreationArgs(const sp<SurfaceFlinger>& flinger, const wp<IBinder>& displayToken,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700203 const std::optional<DisplayId>& displayId);
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700204
205 const sp<SurfaceFlinger> flinger;
206 const wp<IBinder> displayToken;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700207 const std::optional<DisplayId> displayId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700208
Dominik Laskowskie9774092018-12-11 10:04:24 -0800209 int32_t sequenceId{0};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700210 bool isVirtual{false};
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700211 bool isSecure{false};
212 sp<ANativeWindow> nativeWindow;
Lloyd Pique542307f2018-10-19 13:24:08 -0700213 sp<compositionengine::DisplaySurface> displaySurface;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800214 ui::Rotation physicalOrientation{ui::ROTATION_0};
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700215 bool hasWideColorGamut{false};
216 HdrCapabilities hdrCapabilities;
217 int32_t supportedPerFrameMetadata{0};
218 std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>> hwcColorModes;
219 int initialPowerMode{HWC_POWER_MODE_NORMAL};
Dominik Laskowski075d3172018-05-24 15:50:06 -0700220 bool isPrimary{false};
Lloyd Pique688abd42019-02-15 15:42:24 -0800221 Hwc2::PowerAdvisor* powerAdvisor{nullptr};
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700222};
223
chaviwa76b2712017-09-20 12:02:26 -0700224class DisplayRenderArea : public RenderArea {
225public:
Dominik Laskowski718f9602019-11-09 20:01:35 -0800226 DisplayRenderArea(const sp<const DisplayDevice>& display,
227 RotationFlags rotation = ui::Transform::ROT_0)
Ady Abraham8a82ba62020-01-17 12:43:17 -0800228 : DisplayRenderArea(display, display->getBounds(),
229 static_cast<uint32_t>(display->getWidth()),
230 static_cast<uint32_t>(display->getHeight()),
231 display->getCompositionDataSpace(), rotation) {}
Dominik Laskowski718f9602019-11-09 20:01:35 -0800232
233 DisplayRenderArea(sp<const DisplayDevice> display, const Rect& sourceCrop, uint32_t reqWidth,
234 uint32_t reqHeight, ui::Dataspace reqDataSpace, RotationFlags rotation,
235 bool allowSecureLayers = true)
Peiyong Lin0e003c92018-09-17 11:09:51 -0700236 : RenderArea(reqWidth, reqHeight, CaptureFill::OPAQUE, reqDataSpace,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800237 display->getViewport(),
238 applyInversePhysicalOrientation(rotation,
239 display->getPhysicalOrientation())),
240 mDisplay(std::move(display)),
Robert Carrfa8855f2019-02-19 10:05:00 -0800241 mSourceCrop(sourceCrop),
242 mAllowSecureLayers(allowSecureLayers) {}
chaviwa76b2712017-09-20 12:02:26 -0700243
Dominik Laskowski718f9602019-11-09 20:01:35 -0800244 const ui::Transform& getTransform() const override { return mDisplay->getTransform(); }
245 Rect getBounds() const override { return mDisplay->getBounds(); }
246 int getHeight() const override { return mDisplay->getHeight(); }
247 int getWidth() const override { return mDisplay->getWidth(); }
248 bool isSecure() const override { return mAllowSecureLayers && mDisplay->isSecure(); }
249 sp<const DisplayDevice> getDisplayDevice() const override { return mDisplay; }
Chia-I Wu5f6664c2018-08-28 11:01:44 -0700250
251 bool needsFiltering() const override {
Chia-I Wu8730ba82018-08-29 09:25:59 -0700252 // check if the projection from the logical display to the physical
253 // display needs filtering
Dominik Laskowski718f9602019-11-09 20:01:35 -0800254 if (mDisplay->needsFiltering()) {
Chia-I Wu5f6664c2018-08-28 11:01:44 -0700255 return true;
256 }
257
Chia-I Wu8730ba82018-08-29 09:25:59 -0700258 // check if the projection from the logical render area (i.e., the
259 // physical display) to the physical render area requires filtering
Chia-I Wu5f6664c2018-08-28 11:01:44 -0700260 const Rect sourceCrop = getSourceCrop();
261 int width = sourceCrop.width();
262 int height = sourceCrop.height();
263 if (getRotationFlags() & ui::Transform::ROT_90) {
264 std::swap(width, height);
265 }
266 return width != getReqWidth() || height != getReqHeight();
267 }
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700268
269 Rect getSourceCrop() const override {
Alec Mouriadb75f42019-03-28 21:42:24 -0700270 // use the projected display viewport by default.
Chia-I Wu8730ba82018-08-29 09:25:59 -0700271 if (mSourceCrop.isEmpty()) {
Dominik Laskowski718f9602019-11-09 20:01:35 -0800272 return mDisplay->getScissor();
Chia-I Wu8730ba82018-08-29 09:25:59 -0700273 }
274
Alec Mouriadb75f42019-03-28 21:42:24 -0700275 // Recompute the device transformation for the source crop.
276 ui::Transform rotation;
277 ui::Transform translatePhysical;
278 ui::Transform translateLogical;
279 ui::Transform scale;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800280 const Rect& viewport = mDisplay->getViewport();
281 const Rect& scissor = mDisplay->getScissor();
282 const Rect& frame = mDisplay->getFrame();
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700283
Dominik Laskowski718f9602019-11-09 20:01:35 -0800284 const auto flags = ui::Transform::toRotationFlags(mDisplay->getPhysicalOrientation());
Alec Mouriadb75f42019-03-28 21:42:24 -0700285 rotation.set(flags, getWidth(), getHeight());
Dominik Laskowski718f9602019-11-09 20:01:35 -0800286
Alec Mouriadb75f42019-03-28 21:42:24 -0700287 translateLogical.set(-viewport.left, -viewport.top);
288 translatePhysical.set(scissor.left, scissor.top);
289 scale.set(frame.getWidth() / float(viewport.getWidth()), 0, 0,
290 frame.getHeight() / float(viewport.getHeight()));
291 const ui::Transform finalTransform =
292 rotation * translatePhysical * scale * translateLogical;
293 return finalTransform.transform(mSourceCrop);
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700294 }
chaviwa76b2712017-09-20 12:02:26 -0700295
296private:
Dominik Laskowski718f9602019-11-09 20:01:35 -0800297 static RotationFlags applyInversePhysicalOrientation(RotationFlags orientation,
298 ui::Rotation physicalOrientation) {
299 uint32_t inverseRotate90 = 0;
300 uint32_t inverseReflect = 0;
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700301
Dominik Laskowski718f9602019-11-09 20:01:35 -0800302 switch (physicalOrientation) {
303 case ui::ROTATION_0:
304 return orientation;
305
306 case ui::ROTATION_90:
307 inverseRotate90 = ui::Transform::ROT_90;
308 inverseReflect = ui::Transform::ROT_180;
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700309 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800310
311 case ui::ROTATION_180:
312 inverseReflect = ui::Transform::ROT_180;
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700313 break;
Dominik Laskowski718f9602019-11-09 20:01:35 -0800314
315 case ui::ROTATION_270:
316 inverseRotate90 = ui::Transform::ROT_90;
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700317 break;
318 }
319
Dominik Laskowski718f9602019-11-09 20:01:35 -0800320 const uint32_t rotate90 = orientation & ui::Transform::ROT_90;
321 uint32_t reflect = orientation & ui::Transform::ROT_180;
322
323 // Apply reflection for double rotation.
324 if (rotate90 & inverseRotate90) {
325 reflect = ~reflect & ui::Transform::ROT_180;
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700326 }
327
Dominik Laskowski718f9602019-11-09 20:01:35 -0800328 return static_cast<RotationFlags>((rotate90 ^ inverseRotate90) |
329 (reflect ^ inverseReflect));
Chia-I Wuf2aa3112018-08-27 14:54:37 -0700330 }
331
Dominik Laskowski718f9602019-11-09 20:01:35 -0800332 const sp<const DisplayDevice> mDisplay;
chaviwa76b2712017-09-20 12:02:26 -0700333 const Rect mSourceCrop;
Robert Carrfa8855f2019-02-19 10:05:00 -0800334 const bool mAllowSecureLayers;
chaviwa76b2712017-09-20 12:02:26 -0700335};
336
Dominik Laskowski718f9602019-11-09 20:01:35 -0800337} // namespace android