blob: e3217a3228365c329b27d1a55aa36f5d8c947450 [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 *
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080010 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
Dominik Laskowski9dab3432019-03-27 13:21:10 -070016#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080017
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018#include <sys/types.h>
19
Mathias Agopian3f844832013-08-07 21:24:32 -070020/*
21 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
22 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070023
Dominik Laskowski83b88212018-12-11 13:34:06 -080024#include <android-base/thread_annotations.h>
Huihong Luof5029222021-12-16 14:33:46 -080025#include <android/gui/BnSurfaceComposer.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080026#include <android/gui/DisplayStatInfo.h>
27#include <android/gui/DisplayState.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080028#include <android/gui/ISurfaceComposerClient.h>
Steven Moreland2716e112018-02-23 14:57:20 -080029#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080030#include <cutils/compiler.h>
Dominik Laskowskib17c6212022-05-09 09:36:19 -070031#include <ftl/future.h>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040032#include <ftl/non_null.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080033#include <gui/BufferQueue.h>
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -070034#include <gui/CompositorTiming.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080035#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080036#include <gui/ISurfaceComposer.h>
Valerie Hau5de3ad22019-08-20 07:47:43 -070037#include <gui/ITransactionCompletedListener.h>
Huihong Luo05539a12022-02-23 10:29:40 -080038#include <gui/LayerDebugInfo.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070039#include <gui/LayerState.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080040#include <layerproto/LayerProtoHeader.h>
41#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080042#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070043#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070044#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080045#include <ui/FenceTime.h>
46#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010047#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080048#include <utils/Errors.h>
49#include <utils/KeyedVector.h>
50#include <utils/RefBase.h>
51#include <utils/SortedVector.h>
52#include <utils/Trace.h>
53#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070054
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080055#include <compositionengine/OutputColorSetting.h>
56#include <scheduler/Fps.h>
Dominik Laskowski80c77272022-07-08 12:47:29 -070057#include <scheduler/PresentLatencyTracker.h>
Dominik Laskowski8792c112022-07-12 09:03:39 -070058#include <scheduler/Time.h>
Patrick Williams2e9748f2022-08-09 22:48:18 +000059#include <ui/FenceResult.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080060
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070061#include "Display/DisplayMap.h"
62#include "Display/PhysicalDisplay.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070063#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080064#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080065#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020066#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080067#include "Effects/Daltonizer.h"
Robert Carr9b623c32022-03-21 15:55:22 -070068#include "FlagManager.h"
Vishnu Nairaf6d2972022-11-18 06:26:38 +000069#include "FrontEnd/DisplayInfo.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000070#include "FrontEnd/LayerCreationArgs.h"
Vishnu Naira61e4fb2022-10-18 18:29:37 +000071#include "FrontEnd/TransactionHandler.h"
Robert Carr2047fae2016-11-28 14:09:09 -080072#include "LayerVector.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040073#include "Scheduler/RefreshRateSelector.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080074#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070075#include "Scheduler/Scheduler.h"
Dominik Laskowskia93a5312020-07-23 15:10:03 -070076#include "Scheduler/VsyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080077#include "SurfaceFlingerFactory.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -080078#include "ThreadContext.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070079#include "Tracing/LayerTracing.h"
Vishnu Nair7891e962021-11-11 12:07:21 -080080#include "Tracing/TransactionTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080081#include "TransactionCallbackInvoker.h"
Vishnu Nair6b591152021-10-08 11:45:14 -070082#include "TransactionState.h"
Mathias Agopian86303202012-07-24 22:46:10 -070083
Dominik Laskowski83b88212018-12-11 13:34:06 -080084#include <atomic>
85#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080086#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070087#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080088#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080089#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070090#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080091#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070092#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070093#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070094#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080095#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070096#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -070097#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080098#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070099
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500100#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000101#include "Client.h"
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500102
chaviw1d044282017-09-27 12:19:28 -0700103using namespace android::surfaceflinger;
104
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800105namespace android {
106
Lloyd Pique144e1162017-12-20 16:44:52 -0800107class EventThread;
rnleea2ecd832021-07-29 13:58:30 -0700108class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800109class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200110class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -0400111class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700112class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800113class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800114class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700115class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700116class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700117class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200118class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800119class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700120class FrameTracer;
Huihong Luof5029222021-12-16 14:33:46 -0800121class ScreenCapturer;
chaviw60c9d3e2021-06-04 12:52:17 -0500122class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800123
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000124using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800125using gui::CaptureArgs;
126using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800127using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800128using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800129using gui::ScreenCaptureResults;
130
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700131namespace frametimeline {
132class FrameTimeline;
133}
134
Chris Ye0783e992020-06-02 21:34:49 -0700135namespace os {
136 class IInputFlinger;
137}
138
Lloyd Pique542307f2018-10-19 13:24:08 -0700139namespace compositionengine {
140class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800141class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800142
143struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700144} // namespace compositionengine
145
Peiyong Lin833074a2018-08-28 11:53:54 -0700146namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800147class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700148} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700149
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800150enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700151 eTransactionNeeded = 0x01,
152 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700153 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700154 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700155 eTransactionFlushNeeded = 0x10,
156 eTransactionMask = 0x1f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800157};
158
Ady Abraham9dada822022-02-03 10:26:59 -0800159// Latch Unsignaled buffer behaviours
160enum class LatchUnsignaledConfig {
161 // All buffers are latched signaled.
162 Disabled,
163
164 // Latch unsignaled is permitted when a single layer is updated in a frame,
165 // and the update includes just a buffer update (i.e. no sync transactions
166 // or geometry changes).
167 AutoSingleLayer,
168
169 // All buffers are latched unsignaled. This behaviour is discouraged as it
170 // can break sync transactions, stall the display and cause undesired side effects.
171 Always,
172};
ramindani4d48f902021-09-20 21:07:45 +0000173
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800174using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800175
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700176class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700177 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700178 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800179 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700180 private ICompositor,
Dominik Laskowski068173d2021-08-11 17:22:59 -0700181 private scheduler::ISchedulerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800182public:
Peiyong Linf243e5e2020-08-22 17:40:59 -0700183 struct SkipInitializationTag {};
184
185 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
186 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
187
188 // set main thread scheduling policy
189 static status_t setSchedFifo(bool enabled) ANDROID_API;
190
Wei Wang23aa5a62021-06-04 15:56:57 -0700191 // set main thread scheduling attributes
192 static status_t setSchedAttr(bool enabled);
193
Peiyong Linf243e5e2020-08-22 17:40:59 -0700194 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800195
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800196 // If fences from sync Framework are supported.
197 static bool hasSyncFramework;
198
Ady Abraham8cb21882020-08-26 18:22:05 -0700199 // The offset in nanoseconds to use when VsyncController timestamps present fence
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700200 // signaling time.
201 static int64_t dispSyncPresentTimeOffset;
202
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700203 // Some hardware can do RGB->YUV conversion more efficiently in hardware
204 // controlled by HWC than in hardware controlled by the video encoder.
205 // This instruct VirtualDisplaySurface to use HWC for such conversion on
206 // GL composition.
207 static bool useHwcForRgbToYuv;
208
Fabien Sanglard1971b632017-03-10 14:50:03 -0800209 // Controls the number of buffers SurfaceFlinger will allocate for use in
210 // FramebufferSurface
211 static int64_t maxFrameBufferAcquiredBuffers;
212
Brian Lindahla13f2d52020-03-05 11:54:17 +0100213 // Controls the maximum width and height in pixels that the graphics pipeline can support for
214 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
215 static uint32_t maxGraphicsWidth;
216 static uint32_t maxGraphicsHeight;
217
Peiyong Lin13effd12018-07-24 17:01:47 -0700218 // Indicate if device wants color management on its display.
Alec Mouri5f62a602021-09-29 10:52:41 -0700219 static const constexpr bool useColorManagement = true;
Peiyong Lin13effd12018-07-24 17:01:47 -0700220
Peiyong Linb3839ad2018-09-05 15:37:19 -0700221 static bool useContextPriority;
222
Peiyong Lin0256f722018-08-31 15:45:10 -0700223 // The data space and pixel format that SurfaceFlinger expects hardware composer
224 // to composite efficiently. Meaning under most scenarios, hardware composer
225 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700226 static ui::Dataspace defaultCompositionDataspace;
227 static ui::PixelFormat defaultCompositionPixelFormat;
228
229 // The data space and pixel format that SurfaceFlinger expects hardware composer
230 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
231 // hardware composer will accept layers with the data space and pixel format.
232 static ui::Dataspace wideColorGamutCompositionDataspace;
233 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700234
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800235 static constexpr SkipInitializationTag SkipInitialization;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800236
ramindani4d48f902021-09-20 21:07:45 +0000237 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700238
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700239 // must be called before clients can connect
240 void init() ANDROID_API;
241
242 // starts SurfaceFlinger main loop in the current thread
243 void run() ANDROID_API;
244
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700245 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
246 enum class FrameHint { kNone, kActive };
247
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700248 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700249 void scheduleCommit(FrameHint);
250 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700251 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700252 // As above, but also force dirty geometry to repaint.
253 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700254 // Schedule sampling independently from commit or composite.
255 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800256
Lloyd Pique90c115d2018-09-18 21:39:42 -0700257 surfaceflinger::Factory& getFactory() { return mFactory; }
258
Lloyd Pique70d91362018-10-18 16:02:55 -0700259 // The CompositionEngine encapsulates all composition related interfaces and actions.
260 compositionengine::CompositionEngine& getCompositionEngine() const;
261
Dan Stoza436ccf32018-06-21 12:10:12 -0700262 // Obtains a name from the texture pool, or, if the pool is empty, posts a
263 // synchronous message to the main thread to obtain one on the fly
264 uint32_t getNewTexture();
265
Mathias Agopian86303202012-07-24 22:46:10 -0700266 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700267 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700268
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700269 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700270
Dominik Laskowski75848362019-11-11 17:57:20 -0800271 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700272 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700273 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700274
Robert Carr867be372021-06-29 17:36:02 -0700275 void removeHierarchyFromOffscreenLayers(Layer* layer);
Valerie Hauc5686802019-11-22 14:18:09 -0800276 void removeFromOffscreenLayers(Layer* layer);
277
Vishnu Nair07e2a482022-10-18 19:18:16 +0000278 // Called when all clients have released all their references to
279 // this layer. The layer may still be kept alive by its parents but
280 // the client can no longer modify this layer directly.
281 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);
282
Robert Carr6a0382d2021-07-01 15:57:17 -0700283 // TODO: Remove atomic if move dtor to main thread CL lands
284 std::atomic<uint32_t> mNumClones;
285
Robert Carr9a803c32021-01-14 16:57:58 -0800286 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
287 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700288 }
289
Vishnu Nair9b079a22020-01-21 14:36:08 -0800290 // If set, disables reusing client composition buffers. This can be set by
291 // debug.sf.disable_client_composition_cache
292 bool mDisableClientCompositionCache = false;
293
Alec Mouridea1ac52021-06-23 18:12:18 -0700294 // Disables expensive rendering for all displays
295 // This is scheduled on the main thread
296 void disableExpensiveRendering();
chaviw79468ab2021-10-27 11:11:24 -0500297 FloatRect getMaxDisplayBounds();
Alec Mouridea1ac52021-06-23 18:12:18 -0700298
Vishnu Naira3140382022-02-24 14:07:11 -0800299 // If set, composition engine tries to predict the composition strategy provided by HWC
300 // based on the previous frame. If the strategy can be predicted, gpu composition will
301 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
302 bool mPredictCompositionStrategy = false;
303
Alec Mouridda07d92022-04-25 22:39:25 +0000304 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
305 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
306 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
307 // on this behavior to increase contrast for some media sources.
308 bool mTreat170mAsSrgb = false;
309
Peiyong Linf243e5e2020-08-22 17:40:59 -0700310protected:
311 // We're reference counted, never destroy SurfaceFlinger directly
312 virtual ~SurfaceFlinger();
313
Dominik Laskowski263eec42021-07-21 23:13:24 -0700314 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
315 REQUIRES(mStateLock);
316
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800317 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000318 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800319
Dominik Laskowski263eec42021-07-21 23:13:24 -0700320 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
321 template <typename Predicate>
322 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
323 return static_cast<bool>(findDisplay(p));
324 }
325
chaviwba4320c2021-09-15 15:20:53 -0500326 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
327 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
328 }
329
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700330private:
David Sodman0c69cad2017-08-21 12:12:51 -0700331 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700332 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800333 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200334 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700335 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700336 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800337 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800338 friend class LayerRenderArea;
Vishnu Nair00b90132021-11-05 14:03:40 -0700339 friend class LayerTracing;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700340 friend class SurfaceComposerAIDL;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800341
Lloyd Piquef58625d2017-12-19 13:22:33 -0800342 // For unit tests
343 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700344 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700345 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800346
Peiyong Linf243e5e2020-08-22 17:40:59 -0700347 using VsyncModulator = scheduler::VsyncModulator;
348 using TransactionSchedule = scheduler::TransactionSchedule;
349 using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700350 using RenderAreaFuture = ftl::Future<std::unique_ptr<RenderArea>>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700351 using DumpArgs = Vector<String16>;
352 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
353
Robert Carr2047fae2016-11-28 14:09:09 -0800354 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800355 public:
chaviwfd462612018-05-31 16:11:27 -0700356 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700357 State& operator=(const State& other) {
358 // We explicitly don't copy stateSet so that, e.g., mDrawingState
359 // always uses the Drawing StateSet.
360 layersSortedByZ = other.layersSortedByZ;
361 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700362 colorMatrixChanged = other.colorMatrixChanged;
363 if (colorMatrixChanged) {
364 colorMatrix = other.colorMatrix;
365 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800366 globalShadowSettings = other.globalShadowSettings;
367
Dan Stoza412903f2017-04-27 13:42:17 -0700368 return *this;
369 }
370
371 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700372 LayerVector layersSortedByZ;
Dominik Laskowski68399272022-09-15 07:54:46 -0700373
374 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
375 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
376
377 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
378 for (size_t i = 0; i < displays.size(); i++) {
379 const auto& state = displays.valueAt(i);
380 if (state.physical && state.physical->id == displayId) {
381 return i;
382 }
383 }
384
385 return {};
386 }
Robert Carr2047fae2016-11-28 14:09:09 -0800387
Chia-I Wu28f320b2018-05-03 11:02:56 -0700388 bool colorMatrixChanged = true;
389 mat4 colorMatrix;
390
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800391 renderengine::ShadowSettings globalShadowSettings;
392
Edgar Arriaga844fa672020-01-16 14:21:42 -0800393 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700394 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
395 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800396 };
397
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800398 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
399 // state before the buffers are latched. The layer owns the atomic counters and decrements the
400 // count in the main thread when dropping or latching a buffer.
401 //
402 // The binder threads increment the same counter when a new transaction containing a buffer is
403 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
404 // This is done to avoid lock contention with the main thread.
405 class BufferCountTracker {
406 public:
407 void increment(BBinder* layerHandle) {
408 std::lock_guard<std::mutex> lock(mLock);
409 auto it = mCounterByLayerHandle.find(layerHandle);
410 if (it != mCounterByLayerHandle.end()) {
411 auto [name, pendingBuffers] = it->second;
412 int32_t count = ++(*pendingBuffers);
413 ATRACE_INT(name.c_str(), count);
414 } else {
415 ALOGW("Handle not found! %p", layerHandle);
416 }
417 }
418
419 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
420 std::lock_guard<std::mutex> lock(mLock);
421 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
422 }
423
424 void remove(BBinder* layerHandle) {
425 std::lock_guard<std::mutex> lock(mLock);
426 mCounterByLayerHandle.erase(layerHandle);
427 }
428
429 private:
430 std::mutex mLock;
431 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
432 mCounterByLayerHandle GUARDED_BY(mLock);
433 };
434
Peiyong Linf243e5e2020-08-22 17:40:59 -0700435 enum class BootStage {
436 BOOTLOADER,
437 BOOTANIMATION,
438 FINISHED,
439 };
440
Peiyong Linf243e5e2020-08-22 17:40:59 -0700441 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
442 static Dumper dumper(F&& dump) {
443 using namespace std::placeholders;
444 return std::bind(std::forward<F>(dump), _3);
445 }
446
447 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
448 Dumper dumper(F dump) {
449 using namespace std::placeholders;
450 return std::bind(dump, this, _3);
451 }
452
453 template <typename F>
454 Dumper argsDumper(F dump) {
455 using namespace std::placeholders;
456 return std::bind(dump, this, _1, _3);
457 }
458
459 template <typename F>
460 Dumper protoDumper(F dump) {
461 using namespace std::placeholders;
462 return std::bind(dump, this, _1, _2, _3);
463 }
464
465 template <typename... Args,
466 typename Handler = VsyncModulator::VsyncConfigOpt (VsyncModulator::*)(Args...)>
467 void modulateVsync(Handler handler, Args... args) {
468 if (const auto config = (*mVsyncModulator.*handler)(args...)) {
Dominik Laskowski596a2562022-10-28 11:26:12 -0400469 setVsyncConfig(*config, mScheduler->getLeaderVsyncPeriod());
Peiyong Linf243e5e2020-08-22 17:40:59 -0700470 }
471 }
472
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700473 // Maximum allowed number of display frames that can be set through backdoor
474 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700475
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700476 static const size_t MAX_LAYERS = 4096;
477
Peiyong Linf243e5e2020-08-22 17:40:59 -0700478 // Implements IBinder.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800479 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
480 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Steven Thomasd4071902020-03-24 16:02:53 -0700481 bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
482 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800483
Peiyong Linf243e5e2020-08-22 17:40:59 -0700484 // Implements ISurfaceComposer
Huihong Luo07e72362022-02-14 14:26:04 -0800485 sp<IBinder> createDisplay(const String8& displayName, bool secure);
486 void destroyDisplay(const sp<IBinder>& displayToken);
487 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700488 Mutex::Autolock lock(mStateLock);
489 return getPhysicalDisplayIdsLocked();
490 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700491
Huihong Luo07e72362022-02-14 14:26:04 -0800492 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000493 status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo,
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000494 Vector<ComposerState>& state, const Vector<DisplayState>& displays,
495 uint32_t flags, const sp<IBinder>& applyToken,
chaviw308ddba2020-08-11 16:23:51 -0700496 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800497 int64_t desiredPresentTime, bool isAutoTimestamp,
498 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000499 const std::vector<ListenerCallbacks>& listenerCallbacks,
500 uint64_t transactionId) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700501 void bootFinished();
Huihong Luo0a81aa32022-02-22 16:02:36 -0800502 virtual status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800503 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700504 gui::ISurfaceComposer::VsyncSource vsyncSource =
505 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
506 EventRegistrationFlags eventRegistration = {});
Dominik Laskowskif1833852021-03-23 15:06:50 -0700507
Huihong Luof5029222021-12-16 14:33:46 -0800508 status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
509 status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&);
510 status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700511
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800512 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100513 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800514 EXCLUDES(mStateLock);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100515 status_t getStaticDisplayInfo(const sp<IBinder>& displayToken, ui::StaticDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800516 EXCLUDES(mStateLock);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100517 status_t getDynamicDisplayInfo(const sp<IBinder>& displayToken, ui::DynamicDisplayInfo*)
Huihong Luo38603fd2022-02-21 14:32:54 -0800518 EXCLUDES(mStateLock);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800519 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
520 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800521 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700522 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700523 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800524 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
525 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
526 void setGameContentType(const sp<IBinder>& displayToken, bool on);
527 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100528 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800529 const std::vector<ui::Hdr>& hdrTypes);
530 status_t onPullAtom(const int32_t atomId, std::string* pulledData, bool* success);
Huihong Luo05539a12022-02-23 10:29:40 -0800531 status_t getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers);
532 status_t getColorManagement(bool* outGetColorManagement) const;
Peiyong Linc6780972018-10-28 15:24:08 -0700533 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
534 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800535 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700536 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800537 ui::PixelFormat* outFormat,
538 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800539 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700540 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800541 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700542 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800543 uint64_t timestamp, DisplayedFrameStats* outStats) const;
544 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800545 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800546 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800547 const sp<IRegionSamplingListener>& listener);
548 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
549 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
550 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
551 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
552 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100553 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700554 const gui::DisplayModeSpecs&);
555 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800556 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500557 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800558 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400559 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800560 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400561 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800562 const sp<gui::IHdrLayerInfoListener>& listener);
563 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800564 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800565 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500566 status_t getDisplayDecorationSupport(
567 const sp<IBinder>& displayToken,
568 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800569 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800570 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800571 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700572
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000573 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800574 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700575
Huihong Luo3bdef862022-03-03 11:57:19 -0800576 status_t setOverrideFrameRate(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800577
Huihong Luo02186fb2022-02-23 14:21:54 -0800578 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800579
Huihong Luo02186fb2022-02-23 14:21:54 -0800580 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800581
Huihong Luo02186fb2022-02-23 14:21:54 -0800582 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500583 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800584 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500585
Peiyong Linf243e5e2020-08-22 17:40:59 -0700586 // Implements IBinder::DeathRecipient.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800587 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800588
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700589 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400590 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700591 std::optional<hal::VsyncPeriodNanos>) override;
592 void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) override;
593 void onComposerHalRefresh(hal::HWDisplayId) override;
594 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
595 const hal::VsyncPeriodChangeTimeline&) override;
596 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800597 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700598
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700599 // ICompositor overrides:
600
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700601 // Configures physical displays, processing hotplug and/or mode setting via the Composer HAL.
602 void configure() override;
603
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700604 // Commits transactions for layers and displays. Returns whether any state has been invalidated,
605 // i.e. whether a frame should be composited for each display.
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700606 bool commit(TimePoint frameTime, VsyncId, TimePoint expectedVsyncTime) override;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700607
608 // Composites a frame for each display. CompositionEngine performs GPU and/or HAL composition
609 // via RenderEngine and the Composer HAL, respectively.
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700610 void composite(TimePoint frameTime, VsyncId) override;
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700611
612 // Samples the composited frame via RegionSamplingThread.
613 void sample() override;
614
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700615 // ISchedulerCallback overrides:
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700616
617 // Toggles hardware VSYNC by calling into HWC.
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400618 // TODO(b/241286146): Rename for self-explanatory API.
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700619 void setVsyncEnabled(bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400620 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800621 void kernelTimerChanged(bool expired) override;
Ady Abraham62a0be22020-12-08 16:54:10 -0800622 void triggerOnFrameRateOverridesChanged() override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700623
Ana Krulecb9afd792020-06-11 13:16:15 -0700624 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
Ady Abraham3efa3942021-06-24 19:01:25 -0700625 void toggleKernelIdleTimer() REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400626
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400627 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400628
ramindani32cf0602022-03-02 02:30:29 +0000629 // Get the controller and timeout that will help decide how the kernel idle timer will be
630 // configured and what value to use as the timeout.
631 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
632 getKernelIdleTimerProperties(DisplayId) REQUIRES(mStateLock);
633 // Updates the kernel idle timer either through HWC or through sysprop
634 // depending on which controller is provided
635 void updateKernelIdleTimer(std::chrono::milliseconds timeoutMs, KernelIdleTimerController,
636 PhysicalDisplayId) REQUIRES(mStateLock);
Ana Krulecb9afd792020-06-11 13:16:15 -0700637 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
638 // make calls to sys prop each time.
639 bool mKernelIdleTimerEnabled = false;
Ady Abraham29d0da32020-07-16 18:39:33 -0700640 // Show spinner with refresh rate overlay
641 bool mRefreshRateOverlaySpinner = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700642
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400643 void setDesiredActiveMode(display::DisplayModeRequest&&) REQUIRES(mStateLock);
644
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700645 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId);
Marin Shalamanovdd594312021-11-09 16:37:37 +0100646 // Sets the active mode and a new refresh rate in SF.
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700647 void updateInternalStateWithChangedMode() REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100648 // Calls to setActiveMode on the main thread if there is a pending mode change
Ady Abraham27cbed72020-04-10 12:56:59 -0700649 // that needs to be applied.
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700650 void setActiveModeInHwcIfNeeded() REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham690f4612021-07-01 23:24:03 -0700651 void clearDesiredActiveModeState(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100652 // Called when active mode is no longer is progress
Ady Abraham690f4612021-07-01 23:24:03 -0700653 void desiredActiveModeChangeDone(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100654 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700655 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700656 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800657
Alec Mouricdf16792021-12-10 13:16:06 -0800658 // Returns true if the display has a visible HDR layer in its layer stack.
659 bool hasVisibleHdrLayer(const sp<DisplayDevice>& display) REQUIRES(mStateLock);
660
Dominik Laskowskif2595442022-08-29 13:51:57 -0700661 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
662 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800663 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400664 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700665
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400666 status_t setDesiredDisplayModeSpecsInternal(
667 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700668 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800669
Dominik Laskowski3f726402022-11-21 17:21:22 -0500670 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
671 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
672 const scheduler::RefreshRateSelector&)
673 REQUIRES(mStateLock, kMainThreadContext);
674
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700675 void commitTransactions() EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
676 void commitTransactionsLocked(uint32_t transactionFlags)
677 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700678 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800679
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700680 // Returns whether a new buffer has been latched.
681 bool latchBuffers();
Dan Stoza28d46a52020-04-28 09:54:54 -0700682
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700683 void updateLayerGeometry();
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000684 void updateLayerMetadataSnapshot();
Dan Stoza6b9454d2014-11-07 16:00:59 -0800685
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800686 void updateInputFlinger();
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800687 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800688 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
689 std::vector<gui::DisplayInfo>& outDisplayInfos);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800690 void commitInputWindowCommands() REQUIRES(mStateLock);
Riley Andrews03414a12014-07-01 14:22:59 -0700691 void updateCursorAsync();
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700692
Dominik Laskowski59db9562022-10-27 16:18:53 -0400693 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100694 void updatePhaseConfiguration(const Fps&) REQUIRES(mStateLock);
Ady Abraham55fa7272020-09-30 19:19:27 -0700695 void setVsyncConfig(const VsyncModulator::VsyncConfig&, nsecs_t vsyncPeriod);
Riley Andrews03414a12014-07-01 14:22:59 -0700696
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800697
Peiyong Linf243e5e2020-08-22 17:40:59 -0700698 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700699 * Transactions
700 */
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000701 bool applyTransactionState(const FrameTimelineInfo& info,
702 std::vector<ResolvedComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800703 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800704 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800705 const int64_t desiredPresentTime, bool isAutoTimestamp,
Valerie Hau9dab9732019-08-20 09:29:25 -0700706 const client_cache_t& uncacheBuffer, const int64_t postTime,
Vishnu Nair24e3bba2021-02-23 14:19:36 -0800707 uint32_t permissions, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700708 const std::vector<ListenerCallbacks>& listenerCallbacks,
Arthur Hung58144272021-01-16 03:43:53 +0000709 int originPid, int originUid, uint64_t transactionId)
710 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700711 // Flush pending transactions that were presented after desiredPresentTime.
712 bool flushTransactionQueues(VsyncId) REQUIRES(kMainThreadContext);
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700713 // Returns true if there is at least one transaction that needs to be flushed
714 bool transactionFlushNeeded();
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700715 void addTransactionReadyFilters();
716 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
717 const TransactionHandler::TransactionFlushState& flushState)
718 REQUIRES(kMainThreadContext);
719 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
720 const TransactionHandler::TransactionFlushState& flushState)
721 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800722
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000723 uint32_t setClientStateLocked(const FrameTimelineInfo&, ResolvedComposerState&,
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700724 int64_t desiredPresentTime, bool isAutoTimestamp,
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000725 int64_t postTime, uint32_t permissions, uint64_t transactionId)
726 REQUIRES(mStateLock);
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700727
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700728 uint32_t getTransactionFlags() const;
729
Dominik Laskowski94000c42022-03-17 12:55:14 -0700730 // Sets the masked bits, and schedules a commit if needed.
731 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700732 const sp<IBinder>& applyToken = nullptr,
733 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700734
735 // Clears and returns the masked bits.
736 uint32_t clearTransactionFlags(uint32_t mask);
737
chaviw74d90ad2019-04-26 14:45:26 -0700738 void commitOffscreenLayers();
Dominik Laskowski94000c42022-03-17 12:55:14 -0700739
ramindani4d48f902021-09-20 21:07:45 +0000740 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Ady Abraham2739e832022-02-14 17:42:00 -0800741 bool shouldLatchUnsignaled(const sp<Layer>& layer, const layer_state_t&, size_t numStates,
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700742 bool firstTransaction) const;
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700743 bool applyTransactions(std::vector<TransactionState>& transactions, VsyncId)
Vishnu Nair7891e962021-11-11 12:07:21 -0800744 REQUIRES(mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800745 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800746 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
747 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700748 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
749
Peiyong Linf243e5e2020-08-22 17:40:59 -0700750 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700751 * Layer management
752 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000753 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800754
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800755 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
756 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700757
Vishnu Nair84125ac2021-12-02 08:47:48 -0800758 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800759 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700760
Vishnu Nair84125ac2021-12-02 08:47:48 -0800761 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000762 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700763
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000764 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000765 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000766
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800767 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700768
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700769 // add a layer to SurfaceFlinger
Vishnu Naircb8be502022-10-12 19:03:23 +0000770 status_t addClientLayer(const LayerCreationArgs& args, const sp<IBinder>& handle,
771 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700772 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700773
Vishnu Nair4351ad52019-02-11 14:13:02 -0800774 // Traverse through all the layers and compute and cache its bounds.
775 void computeLayerBounds();
776
Peiyong Linf243e5e2020-08-22 17:40:59 -0700777 // Boot animation, on/off animations and screen capture
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700778 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700779
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700780 ftl::SharedFuture<FenceResult> captureScreenCommon(RenderAreaFuture, TraverseLayersFunction,
781 ui::Size bufferSize, ui::PixelFormat,
782 bool allowProtected, bool grayscale,
783 const sp<IScreenCaptureListener>&);
784 ftl::SharedFuture<FenceResult> captureScreenCommon(
Sally Qi59a9f502021-10-12 18:53:23 +0000785 RenderAreaFuture, TraverseLayersFunction,
786 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
787 bool grayscale, const sp<IScreenCaptureListener>&);
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700788 ftl::SharedFuture<FenceResult> renderScreenImpl(
Patrick Williams7584c6a2022-10-29 02:10:58 +0000789 std::unique_ptr<RenderArea>, TraverseLayersFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000790 const std::shared_ptr<renderengine::ExternalTexture>&, bool canCaptureBlackoutContent,
Patrick Williams377c0142022-10-13 17:33:38 +0000791 bool regionSampling, bool grayscale, ScreenCaptureResults&) EXCLUDES(mStateLock)
792 REQUIRES(kMainThreadContext);
chaviw03900772020-08-18 12:34:51 -0700793
chaviw4b9d5e12020-08-04 18:30:35 -0700794 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
795 // matching ownerUid
796 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid, const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700797
Romain Guy11d63f42017-07-20 12:47:14 -0700798 void readPersistentProperties();
799
rnleeed20fa42021-08-10 18:00:03 -0700800 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700801
Peiyong Linf243e5e2020-08-22 17:40:59 -0700802 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700803 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700804 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700805
806 // Called during boot, and restart after system_server death.
Andy McFadden13a082e2012-08-24 10:16:42 -0700807 void initializeDisplays();
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700808 void onInitializeDisplays() REQUIRES(mStateLock, kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700809
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700810 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
811 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700812 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700813 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700814
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700815 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -0700816 const sp<DisplayDevice> nullDisplay;
817 return mDisplays.get(displayToken).value_or(std::cref(nullDisplay));
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700818 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700819
Ady Abraham690f4612021-07-01 23:24:03 -0700820 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
821 REQUIRES(mStateLock) {
822 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
823 }
824
825 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
826 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
827 return getDisplayDeviceLocked(token);
828 }
829 return nullptr;
830 }
831
Dominik Laskowski3c363242022-04-07 10:44:12 -0700832 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
833 // TODO(b/182939859): Replace tokens with IDs for display lookup.
834 return findDisplay([id](const auto& display) { return display.getId() == id; });
835 }
836
837 // Returns the primary display or (for foldables) the active display, assuming that the inner
838 // and outer displays have mutually exclusive power states.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700839 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700840 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700841 }
842
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700843 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -0700844 if (const auto display = getDisplayDeviceLocked(mActiveDisplayId)) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700845 return display;
846 }
Dominik Laskowski3c363242022-04-07 10:44:12 -0700847 // The active display is outdated, so fall back to the primary display.
Dominik Laskowskie591b552022-09-09 10:44:56 -0700848 mActiveDisplayId = getPrimaryDisplayIdLocked();
849 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -0700850 }
851
Ady Abraham3efa3942021-06-24 19:01:25 -0700852 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700853 Mutex::Autolock lock(mStateLock);
854 return getDefaultDisplayDeviceLocked();
855 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200856
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700857 using DisplayDeviceAndSnapshot =
858 std::pair<sp<DisplayDevice>, display::PhysicalDisplay::SnapshotRef>;
859
860 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
861 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
862 return [this](const display::PhysicalDisplay& display) REQUIRES(
863 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
864 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
865 return std::make_pair(std::move(device), display.snapshotRef());
866 }
867
868 return {};
869 };
870 }
871
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700872 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
873 template <typename Predicate>
874 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
875 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
876 [&](const auto& pair) { return p(*pair.second); });
877
878 return it == mDisplays.end() ? nullptr : it->second;
879 }
880
Ady Abrahamed3290f2021-05-17 15:12:14 -0700881 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
882
Mathias Agopian87baae12012-07-31 12:38:26 -0700883 // mark a region of a layer stack dirty. this updates the dirty
884 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700885 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700886
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700887 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
888 REQUIRES(mStateLock) {
889 return {layerStack,
890 PhysicalDisplayId::tryCast(displayId)
891 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
892 .transform(&display::PhysicalDisplay::isInternal)
893 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -0700894 }
895
Peiyong Linf243e5e2020-08-22 17:40:59 -0700896 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700897 * H/W composer
898 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100899 // The following thread safety rules apply when accessing HWComposer:
900 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
901 // acquire mStateLock.
902 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -0700903 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +0100904 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -0700905 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700906
Peiyong Linf243e5e2020-08-22 17:40:59 -0700907 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700908 * Compositing
909 */
Dominik Laskowski80c77272022-07-08 12:47:29 -0700910 void postComposition() REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -0700911
Peiyong Linf243e5e2020-08-22 17:40:59 -0700912 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -0700913 * Display management
914 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800915 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
916 REQUIRES(mStateLock);
917
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700918 // TODO(b/241285876): Move to DisplayConfigurator.
919 //
920 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
921 // commit display transactions.
922 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
923 EXCLUDES(mHotplugMutex);
924
Dominik Laskowskibb66e632022-08-17 08:00:25 -0700925 // Returns a string describing the hotplug, or nullptr if it was rejected.
926 const char* processHotplug(PhysicalDisplayId, hal::HWDisplayId, bool connected,
927 DisplayIdentificationInfo&&) REQUIRES(mStateLock)
928 REQUIRES(kMainThreadContext);
929
Lloyd Pique542307f2018-10-19 13:24:08 -0700930 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -0700931 const wp<IBinder>& displayToken,
932 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -0700933 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +0100934 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700935 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700936 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -0400937 void processDisplayRemoved(const wp<IBinder>& displayToken)
938 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +0100939 void processDisplayChanged(const wp<IBinder>& displayToken,
940 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700941 const DisplayDeviceState& drawingState)
942 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700943
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800944 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800945
Peiyong Linf243e5e2020-08-22 17:40:59 -0700946 /*
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700947 * VSYNC
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700948 */
Ady Abraham2492a022020-07-24 11:09:55 -0700949 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700950
Ady Abraham4f960d12021-10-13 16:59:49 -0700951 void setHWCVsyncEnabled(PhysicalDisplayId id, hal::Vsync enabled) {
952 mLastHWCVsyncState = enabled;
953 getHwComposer().setVsyncEnabled(id, enabled);
954 }
955
Dominik Laskowski5d164f22022-07-07 07:56:07 -0700956 using FenceTimePtr = std::shared_ptr<FenceTime>;
Ady Abraham6c1b7ac2021-03-31 16:56:03 -0700957
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700958 const FenceTimePtr& getPreviousPresentFence(TimePoint frameTime, Period)
Dominik Laskowski5d164f22022-07-07 07:56:07 -0700959 REQUIRES(kMainThreadContext);
Alec Mouri6d414b52020-03-17 11:18:05 -0700960
Dominik Laskowski5d164f22022-07-07 07:56:07 -0700961 // Blocks the thread waiting for up to graceTimeMs in case the fence is about to signal.
962 static bool isFencePending(const FenceTimePtr&, int graceTimeMs);
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700963
Ady Abraham5facfb12020-04-22 15:18:31 -0700964 // Calculates the expected present time for this frame. For negative offsets, performs a
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700965 // correction using the predicted vsync for the next frame instead.
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700966 TimePoint calculateExpectedPresentTime(TimePoint frameTime) const;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700967
Dominik Laskowskic2867142019-01-21 11:33:38 -0800968 /*
969 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700970 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700971 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +0200972 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700973 const sp<display::DisplayToken> nullToken;
974 return mPhysicalDisplays.get(displayId)
975 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
976 .value_or(std::cref(nullToken));
Dominik Laskowski075d3172018-05-24 15:50:06 -0700977 }
978
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200979 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700980 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700981
Dominik Laskowski3c363242022-04-07 10:44:12 -0700982 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700983 //
Dominik Laskowski3c363242022-04-07 10:44:12 -0700984 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
985 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
986 // display because SF does not support disconnecting it, though in practice HWC may circumvent
987 // this limitation.)
988 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
989 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -0700990 }
991
Dominik Laskowski3c363242022-04-07 10:44:12 -0700992 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700993 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -0700994 }
995
Dominik Laskowski3dce4f42021-03-08 20:48:28 -0800996 // Toggles use of HAL/GPU virtual displays.
997 void enableHalVirtualDisplays(bool);
998
999 // Virtual display lifecycle for ID generation and HAL allocation.
Dominik Laskowski263eec42021-07-21 23:13:24 -07001000 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat) REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001001 void releaseVirtualDisplay(VirtualDisplayId);
1002
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001003 void onActiveDisplayChangedLocked(const sp<DisplayDevice>& activeDisplay)
1004 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001005
Dominik Laskowski68399272022-09-15 07:54:46 -07001006 void onActiveDisplaySizeChanged(const sp<const DisplayDevice>&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001007
Dominik Laskowskic2867142019-01-21 11:33:38 -08001008 /*
1009 * Debugging & dumpsys
1010 */
Alec Mouri67617332022-09-26 21:37:01 +00001011 void dumpAllLocked(const DumpArgs& args, const std::string& compositionLayers,
1012 std::string& result) const REQUIRES(mStateLock);
Ady Abraham5ad28d62022-08-11 11:26:57 -07001013 void dumpHwcLayersMinidumpLocked(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001014
1015 void appendSfConfigString(std::string& result) const;
1016 void listLayersLocked(std::string& result) const;
1017 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1018 void clearStatsLocked(const DumpArgs& args, std::string& result);
1019 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001020 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001021 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001022
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001023 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1024 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1025 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001026
1027 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1028 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001029 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001030 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001031 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001032
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001033 LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
Vishnu Nair0f085c62019-08-30 08:49:12 -07001034 void dumpOffscreenLayersProto(LayersProto& layersProto,
Vishnu Nair00b90132021-11-05 14:03:40 -07001035 uint32_t traceFlags = LayerTracing::TRACE_ALL) const;
chaviw0a398992021-08-13 10:13:01 -05001036 void dumpDisplayProto(LayersTraceProto& layersTraceProto) const;
1037
Alec Mouri6b9e9912020-01-21 10:50:24 -08001038 // Dumps state from HW Composer
1039 void dumpHwc(std::string& result) const;
Vishnu Nair00b90132021-11-05 14:03:40 -07001040 LayersProto dumpProtoFromMainThread(uint32_t traceFlags = LayerTracing::TRACE_ALL)
Vishnu Nair8406fd72019-07-30 11:29:31 -07001041 EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001042 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001043 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001044
Dominik Laskowskic2867142019-01-21 11:33:38 -08001045 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1046
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001047 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001048
1049 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1050 return doDump(fd, args, asProto);
1051 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001052
chaviw17ac24b2021-01-28 18:50:05 -08001053 static mat4 calculateColorMatrix(float saturation);
1054
Chia-I Wu28f320b2018-05-03 11:02:56 -07001055 void updateColorMatrixLocked();
1056
Peiyong Linf243e5e2020-08-22 17:40:59 -07001057 // Verify that transaction is being called by an approved process:
1058 // either AID_GRAPHICS or AID_SYSTEM.
1059 status_t CheckTransactCodeCredentials(uint32_t code);
1060
Ady Abrahame46243a2021-02-23 19:33:49 -08001061 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001062
Peiyong Linf243e5e2020-08-22 17:40:59 -07001063 /*
1064 * Generic Layer Metadata
1065 */
1066 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1067
Ady Abraham899dcdb2021-06-15 16:56:21 -07001068 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1069 std::chrono::nanoseconds presentLatency);
1070 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001071
Ady Abraham3efa3942021-06-24 19:01:25 -07001072 void updateInternalDisplayVsyncLocked(const sp<DisplayDevice>& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001073 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001074
John Reck49d9ad32022-02-23 19:03:31 -05001075 bool isHdrLayer(Layer* layer) const;
1076
ramindani06e518e2022-03-14 18:47:53 +00001077 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1078 REQUIRES(mStateLock);
1079
Peiyong Linf243e5e2020-08-22 17:40:59 -07001080 sp<StartPropertySetThread> mStartPropertySetThread;
Lloyd Pique90c115d2018-09-18 21:39:42 -07001081 surfaceflinger::Factory& mFactory;
Vishnu Nair7891e962021-11-11 12:07:21 -08001082 pid_t mPid;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001083 std::future<void> mRenderEnginePrimeCacheFuture;
1084
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001085 // access must be protected by mStateLock
1086 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001087 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001088 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001089 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001090 SortedVector<sp<Layer>> mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001091
Chia-I Wu28f320b2018-05-03 11:02:56 -07001092 // global color transform states
1093 Daltonizer mDaltonizer;
1094 float mGlobalSaturationFactor = 1.0f;
1095 mat4 mClientColorMatrix;
1096
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001097 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
Alec Mouri601393f2020-02-21 13:26:52 -08001098 // If there are more GraphicBufferProducers tracked by SurfaceFlinger than
1099 // this threshold, then begin logging.
1100 size_t mGraphicBufferProducerListSizeLogThreshold =
1101 static_cast<size_t>(0.95 * static_cast<double>(MAX_LAYERS));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001102
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001103 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001104 bool mLayersRemoved = false;
1105 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001106
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001107 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001108 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001109
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001110 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001111 const nsecs_t mBootTime = systemTime();
Alec Mouri5f487d42020-02-06 09:26:19 -08001112 bool mIsUserBuild = true;
Mathias Agopian3094df32012-06-18 18:06:45 -07001113
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001114 // Can only accessed from the main thread, these members
1115 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001116 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001117 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001118
Robert Carr167bdde2021-07-28 11:26:51 -07001119 // VisibleRegions dirty is already cleared by postComp, but we need to track it to prevent
1120 // extra work in the HDR layer info listener.
1121 bool mVisibleRegionsWereDirtyThisFrame = false;
1122 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1123 // scene hasn't changed
1124 bool mAddingHDRLayerInfoListener = false;
John Reck49d9ad32022-02-23 19:03:31 -05001125 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001126
Robert Carre450fb52021-06-11 13:21:09 -07001127 // Set during transaction application stage to track if the input info or children
1128 // for a layer has changed.
1129 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001130 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001131 bool mSomeChildrenChanged;
Robert Carr167bdde2021-07-28 11:26:51 -07001132 bool mSomeDataspaceChanged = false;
Robert Carrb552ff52021-06-11 13:35:54 -07001133 bool mForceTransactionDisplayChange = false;
Robert Carre450fb52021-06-11 13:21:09 -07001134
Vishnu Nair0a4fb002022-08-08 02:40:42 +00001135 // Set if LayerMetadata has changed since the last LayerMetadata snapshot.
1136 bool mLayerMetadataSnapshotNeeded = false;
1137
Alec Mouri5c9c9602020-09-01 15:10:40 -07001138 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001139 // latched.
Huihong Luoa339d0a2022-02-05 09:42:42 -08001140 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001141 // Tracks layers that need to update a display's dirty region.
1142 std::vector<sp<Layer>> mLayersPendingRefresh;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001143
Alec Mouricc0fc602019-02-26 21:45:19 -08001144 // True if in the previous frame at least one layer was composed via the GPU.
Dan Stoza05dacfb2016-07-01 13:33:38 -07001145 bool mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001146 // True if in the previous frame at least one layer was composed via HW Composer.
1147 // Note that it is possible for a frame to be composed via both client and device
1148 // composition, for example in the case of overlays.
1149 bool mHadDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001150 // True if in the previous frame, the client composition was skipped by reusing the buffer
1151 // used in a previous composition. This can happed if the client composition requests
1152 // did not change.
1153 bool mReusedClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001154
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001155 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001156
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001157 struct HotplugEvent {
1158 hal::HWDisplayId hwcDisplayId;
1159 hal::Connection connection = hal::Connection::INVALID;
1160 };
1161
1162 std::mutex mHotplugMutex;
1163 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001164
Dominik Laskowskieb627312022-04-07 09:13:16 -07001165 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1166 // never removed, so take precedence over external and virtual displays.
1167 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001168 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001169 display::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
1170
1171 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001172
Dominik Laskowskie591b552022-09-09 10:44:56 -07001173 // The inner or outer display for foldables, assuming they have mutually exclusive power states.
1174 PhysicalDisplayId mActiveDisplayId GUARDED_BY(mStateLock);
1175
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001176 struct {
1177 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1178 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1179 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001180
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001181 std::atomic_uint mDebugFlashDelay = 0;
1182 std::atomic_bool mDebugDisableHWC = false;
1183 std::atomic_bool mDebugDisableTransformHint = false;
1184 std::atomic<nsecs_t> mDebugInTransaction = 0;
1185 std::atomic_bool mForceFullDamage = false;
1186
Alec Mouridd8bf2d2021-05-08 16:36:33 -07001187 bool mLayerCachingEnabled = false;
Ady Abrahamadb9a992019-09-19 21:21:55 +00001188 bool mPropagateBackpressureClientComposition = false;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001189
Vishnu Nair00b90132021-11-05 14:03:40 -07001190 LayerTracing mLayerTracing{*this};
Vishnu Nair7891e962021-11-11 12:07:21 -08001191 bool mLayerTracingEnabled = false;
1192
Dominik Laskowski46471e62022-01-14 15:34:03 -08001193 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001194 std::atomic<bool> mTracingEnabledChanged = false;
1195
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001196 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001197 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001198 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001199
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001200 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001201
Lucas Dupin00f16422020-03-11 11:33:04 -07001202 // If blurs should be enabled on this device.
1203 bool mSupportsBlur = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001204 // If blurs are considered expensive and should require high GPU frequency.
1205 bool mBlursAreExpensive = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001206 std::atomic<uint32_t> mFrameMissedCount = 0;
1207 std::atomic<uint32_t> mHwcFrameMissedCount = 0;
1208 std::atomic<uint32_t> mGpuFrameMissedCount = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001209
Robert Carr9a803c32021-01-14 16:57:58 -08001210 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001211
Dan Stoza436ccf32018-06-21 12:10:12 -07001212 // We maintain a pool of pre-generated texture names to hand out to avoid
1213 // layer creation needing to run on the main thread (which it would
1214 // otherwise need to do to access RenderEngine).
1215 std::mutex mTexturePoolMutex;
1216 uint32_t mTexturePoolSize = 0;
1217 std::vector<uint32_t> mTexturePool;
1218
chaviweadf0d42019-08-12 13:28:29 -07001219 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001220
Steven Morelanda904bb92019-07-02 17:37:23 -07001221 // to linkToDeath
1222 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001223 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1224 // different threads without a lock and could trigger unsynchronized writes to
1225 // to mWindowManager or mInputFlinger
1226 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001227
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001228 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001229
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001230 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001231
Peiyong Lina3ea5592019-02-10 14:45:00 -08001232 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1233 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1234 // 2. be one of the supported color modes returned by hardware composer, otherwise
1235 // it will not be respected.
1236 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1237 // is not set to 1.
1238 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1239 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1240
Dominik Laskowski788945b2022-08-30 12:10:56 -07001241 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1242 // If false, wide color modes are filtered out for all internal displays.
1243 bool mSupportsWideColor = false;
1244
Peiyong Lin9d846a52018-11-05 13:18:20 -08001245 ui::Dataspace mDefaultCompositionDataspace;
1246 ui::Dataspace mWideColorGamutCompositionDataspace;
Yichi Chenda901bf2019-06-28 14:58:27 +08001247 ui::Dataspace mColorSpaceAgnosticDataspace;
Alec Mouri6da0e272022-02-07 12:45:57 -08001248 float mDimmingRatio = -1.f;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001249
Patrick Williams0a525a42022-10-26 20:20:50 +00001250 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Lloyd Pique70d91362018-10-18 16:02:55 -07001251 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Garfield Tan9c9c1912021-07-19 12:02:16 -07001252 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1253 // any mutex.
1254 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001255
Dominik Laskowskif06d68e2021-03-24 19:40:03 -07001256 const std::string mHwcServiceName;
1257
Peiyong Linf243e5e2020-08-22 17:40:59 -07001258 /*
Ana Krulecb43429d2019-01-09 14:28:51 -08001259 * Scheduler
1260 */
Dominik Laskowski068173d2021-08-11 17:22:59 -07001261 std::unique_ptr<scheduler::Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001262 scheduler::ConnectionHandle mAppConnectionHandle;
1263 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001264
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001265 // Stores phase offsets configured per refresh rate.
Ady Abraham8287e852020-08-12 14:44:58 -07001266 std::unique_ptr<scheduler::VsyncConfiguration> mVsyncConfiguration;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001267
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001268 // Optional to defer construction until PhaseConfiguration is created.
Ady Abraham23ea9da2021-07-14 16:32:56 -07001269 sp<VsyncModulator> mVsyncModulator;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001270
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001271 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Dominik Laskowski80c77272022-07-08 12:47:29 -07001272 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001273
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001274 struct FenceWithFenceTime {
1275 sp<Fence> fence = Fence::NO_FENCE;
1276 FenceTimePtr fenceTime = FenceTime::NO_FENCE;
1277 };
1278 std::array<FenceWithFenceTime, 2> mPreviousPresentFences;
1279
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001280 TimePoint mScheduledPresentTime GUARDED_BY(kMainThreadContext);
1281 TimePoint mExpectedPresentTime GUARDED_BY(kMainThreadContext);
1282
Marin Shalamanovc75b0772020-06-12 22:29:11 +02001283 hal::Vsync mHWCVsyncPendingState = hal::Vsync::DISABLE;
Ady Abraham4f960d12021-10-13 16:59:49 -07001284 hal::Vsync mLastHWCVsyncState = hal::Vsync::DISABLE;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001285
Ady Abrahamb838aed2019-02-12 15:30:16 -08001286 // below flags are set by main thread only
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001287 bool mSetActiveModePending = false;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001288
Kevin DuBois413287f2019-02-25 08:46:47 -08001289 bool mLumaSampling = true;
1290 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001291 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001292 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001293 ui::DisplayPrimaries mInternalDisplayPrimaries;
Kevin DuBois413287f2019-02-25 08:46:47 -08001294
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001295 const float mEmulatedDisplayDensity;
Roman Kiryanov3388bf92022-11-11 15:35:16 -08001296 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001297
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001298 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001299 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001300 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001301
Xiang Wang839fe5b2022-04-04 17:39:38 +00001302 std::unique_ptr<Hwc2::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001303
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001304 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001305
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001306 // Flag used to set override desired display mode from backdoor
1307 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001308
1309 // A set of layers that have no parent so they are not drawn on screen.
1310 // Should only be accessed by the main thread.
1311 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1312 // be any issues with a raw pointer referencing an invalid object.
1313 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001314
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001315 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001316
1317 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1318 GUARDED_BY(mStateLock);
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001319 mutable std::mutex mCreatedLayersLock;
arthurhungdba591c2021-02-08 17:28:49 +08001320 struct LayerCreatedState {
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -08001321 LayerCreatedState(const wp<Layer>& layer, const wp<Layer> parent, bool addToRoot)
1322 : layer(layer), initialParent(parent), addToRoot(addToRoot) {}
arthurhungdba591c2021-02-08 17:28:49 +08001323 wp<Layer> layer;
1324 // Indicates the initial parent of the created layer, only used for creating layer in
1325 // SurfaceFlinger. If nullptr, it may add the created layer into the current root layers.
Garfield Tandbc93d72021-10-26 18:28:57 -07001326 wp<Layer> initialParent;
chaviwe0c7b822021-07-20 10:16:05 -05001327 // Indicates whether the layer getting created should be added at root if there's no parent
1328 // and has permission ACCESS_SURFACE_FLINGER. If set to false and no parent, the layer will
1329 // be added offscreen.
1330 bool addToRoot;
arthurhungdba591c2021-02-08 17:28:49 +08001331 };
1332
1333 // A temporay pool that store the created layers and will be added to current state in main
1334 // thread.
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001335 std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001336 bool commitCreatedLayers(VsyncId);
1337 void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001338
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001339 mutable std::mutex mMirrorDisplayLock;
1340 struct MirrorDisplayState {
1341 MirrorDisplayState(ui::LayerStack layerStack, sp<IBinder>& rootHandle,
1342 const sp<Client>& client)
1343 : layerStack(layerStack), rootHandle(rootHandle), client(client) {}
1344
1345 ui::LayerStack layerStack;
1346 sp<IBinder> rootHandle;
1347 const sp<Client> client;
1348 };
1349 std::vector<MirrorDisplayState> mMirrorDisplays GUARDED_BY(mMirrorDisplayLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001350 bool commitMirrorDisplays(VsyncId);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001351
Ady Abraham1273ac12021-08-26 17:31:53 -07001352 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001353
Ady Abraham1b11bc62021-06-03 19:51:19 -07001354 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001355 return hasDisplay(
1356 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001357 }
1358
chaviw60c9d3e2021-06-04 12:52:17 -05001359 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001360
Robert Carr9b623c32022-03-21 15:55:22 -07001361 FlagManager mFlagManager;
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001362
1363 // returns the framerate of the layer with the given sequence ID
1364 float getLayerFramerate(nsecs_t now, int32_t id) const {
1365 return mScheduler->getLayerFramerate(now, id);
1366 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001367
Matt Buckley50c44062022-01-17 20:48:10 +00001368 bool mPowerHintSessionEnabled;
1369
Matt Buckleyef51fba2021-10-12 19:30:12 +00001370 struct {
Matt Buckley50c44062022-01-17 20:48:10 +00001371 bool late = false;
1372 bool early = false;
1373 } mPowerHintSessionMode;
Ady Abrahame9ebce02022-02-03 12:05:06 -08001374
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07001375 TransactionHandler mTransactionHandler;
Vishnu Nairaf6d2972022-11-18 06:26:38 +00001376 display::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos;
Huihong Luof5029222021-12-16 14:33:46 -08001377};
1378
1379class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1380public:
Greg Kaisera5628662022-02-28 07:18:04 -08001381 SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001382
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001383 binder::Status bootFinished() override;
1384 binder::Status createDisplayEventConnection(
1385 VsyncSource vsyncSource, EventRegistration eventRegistration,
1386 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001387 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001388 binder::Status createDisplay(const std::string& displayName, bool secure,
1389 sp<IBinder>* outDisplay) override;
1390 binder::Status destroyDisplay(const sp<IBinder>& display) override;
1391 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001392 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001393 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001394 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001395 binder::Status getDisplayStats(const sp<IBinder>& display,
1396 gui::DisplayStatInfo* outStatInfo) override;
1397 binder::Status getDisplayState(const sp<IBinder>& display,
1398 gui::DisplayState* outState) override;
Huihong Luoa79ddf42022-02-17 00:01:38 -08001399 binder::Status getStaticDisplayInfo(const sp<IBinder>& display,
1400 gui::StaticDisplayInfo* outInfo) override;
Huihong Luo38603fd2022-02-21 14:32:54 -08001401 binder::Status getDynamicDisplayInfo(const sp<IBinder>& display,
1402 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001403 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1404 gui::DisplayPrimaries* outPrimaries) override;
1405 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1406 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001407 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1408 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001409 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001410 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1411 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001412 binder::Status captureDisplay(const DisplayCaptureArgs&,
1413 const sp<IScreenCaptureListener>&) override;
1414 binder::Status captureDisplayById(int64_t, const sp<IScreenCaptureListener>&) override;
1415 binder::Status captureLayers(const LayerCaptureArgs&,
1416 const sp<IScreenCaptureListener>&) override;
Dominik Laskowski66296b22022-07-12 08:20:36 -07001417
1418 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001419 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1420 return binder::Status::ok();
1421 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001422 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001423 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001424 }
1425
Huihong Luo05539a12022-02-23 10:29:40 -08001426 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1427 const std::vector<int32_t>& hdrTypes) override;
1428 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001429 binder::Status getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers) override;
1430 binder::Status getColorManagement(bool* outGetColorManagement) override;
1431 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1432 binder::Status getDisplayedContentSamplingAttributes(
1433 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1434 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1435 int8_t componentMask,
1436 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001437 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1438 int64_t timestamp,
1439 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001440 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001441 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1442 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001443 binder::Status addRegionSamplingListener(
1444 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1445 const sp<gui::IRegionSamplingListener>& listener) override;
1446 binder::Status removeRegionSamplingListener(
1447 const sp<gui::IRegionSamplingListener>& listener) override;
1448 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1449 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1450 binder::Status addTunnelModeEnabledListener(
1451 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1452 binder::Status removeTunnelModeEnabledListener(
1453 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001454 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1455 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001456 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1457 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001458 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1459 bool* outSupport) override;
1460 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1461 const gui::DisplayBrightness& brightness) override;
1462 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1463 const sp<gui::IHdrLayerInfoListener>& listener) override;
1464 binder::Status removeHdrLayerInfoListener(
1465 const sp<IBinder>& displayToken,
1466 const sp<gui::IHdrLayerInfoListener>& listener) override;
1467 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001468 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1469 const gui::Color& spotColor, float lightPosY,
1470 float lightPosZ, float lightRadius) override;
1471 binder::Status getDisplayDecorationSupport(
1472 const sp<IBinder>& displayToken,
1473 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
1474 binder::Status setOverrideFrameRate(int32_t uid, float frameRate) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001475 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1476 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
1477 binder::Status addWindowInfosListener(
1478 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
1479 binder::Status removeWindowInfosListener(
1480 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Huihong Luof5029222021-12-16 14:33:46 -08001481
1482private:
Huihong Luo07e72362022-02-14 14:26:04 -08001483 static const constexpr bool kUsePermissionCache = true;
1484 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001485 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001486 status_t checkReadFrameBufferPermission();
Huihong Luo07e72362022-02-14 14:26:04 -08001487
1488private:
Huihong Luof5029222021-12-16 14:33:46 -08001489 sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001490};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001491
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001492} // namespace android