blob: 550319576bf5e4ba2104c8924f821b85a1c35a00 [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 Laskowski80872bd2022-11-15 11:34:33 -050031#include <ftl/algorithm.h>
Dominik Laskowskib17c6212022-05-09 09:36:19 -070032#include <ftl/future.h>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040033#include <ftl/non_null.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080034#include <gui/BufferQueue.h>
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -070035#include <gui/CompositorTiming.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080036#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080037#include <gui/ISurfaceComposer.h>
Huihong Luoffee3bc2023-01-17 16:14:35 +000038#include <gui/ITransactionCompletedListener.h>
Huihong Luo05539a12022-02-23 10:29:40 -080039#include <gui/LayerDebugInfo.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070040#include <gui/LayerState.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080041#include <layerproto/LayerProtoHeader.h>
42#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080043#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070044#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070045#include <system/graphics.h>
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050046#include <ui/DisplayMap.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080047#include <ui/FenceTime.h>
48#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010049#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080050#include <utils/Errors.h>
51#include <utils/KeyedVector.h>
52#include <utils/RefBase.h>
53#include <utils/SortedVector.h>
54#include <utils/Trace.h>
55#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070056
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080057#include <compositionengine/OutputColorSetting.h>
58#include <scheduler/Fps.h>
Dominik Laskowski80c77272022-07-08 12:47:29 -070059#include <scheduler/PresentLatencyTracker.h>
Dominik Laskowski8792c112022-07-12 09:03:39 -070060#include <scheduler/Time.h>
Dominik Laskowski1c99a002023-01-20 17:10:36 -050061#include <scheduler/TransactionSchedule.h>
Dominik Laskowski63f12792023-01-21 16:58:22 -050062#include <scheduler/interface/CompositionCoverage.h>
63#include <scheduler/interface/ICompositor.h>
Patrick Williams2e9748f2022-08-09 22:48:18 +000064#include <ui/FenceResult.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080065
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070066#include "Display/PhysicalDisplay.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070067#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080068#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080069#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020070#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080071#include "Effects/Daltonizer.h"
Robert Carr9b623c32022-03-21 15:55:22 -070072#include "FlagManager.h"
Vishnu Nairaf6d2972022-11-18 06:26:38 +000073#include "FrontEnd/DisplayInfo.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000074#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000075#include "FrontEnd/LayerLifecycleManager.h"
Vishnu Nair7aa0eb72023-01-24 03:59:27 +000076#include "FrontEnd/LayerSnapshot.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000077#include "FrontEnd/LayerSnapshotBuilder.h"
Vishnu Naira61e4fb2022-10-18 18:29:37 +000078#include "FrontEnd/TransactionHandler.h"
Robert Carr2047fae2016-11-28 14:09:09 -080079#include "LayerVector.h"
Leon Scroggins IIIc275df42023-02-07 16:40:21 -050080#include "Scheduler/ISchedulerCallback.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040081#include "Scheduler/RefreshRateSelector.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080082#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070083#include "Scheduler/Scheduler.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080084#include "SurfaceFlingerFactory.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -080085#include "ThreadContext.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070086#include "Tracing/LayerTracing.h"
Vishnu Nair7891e962021-11-11 12:07:21 -080087#include "Tracing/TransactionTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080088#include "TransactionCallbackInvoker.h"
Vishnu Nair6b591152021-10-08 11:45:14 -070089#include "TransactionState.h"
Mathias Agopian86303202012-07-24 22:46:10 -070090
Dominik Laskowski83b88212018-12-11 13:34:06 -080091#include <atomic>
92#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080093#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070094#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080095#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080096#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070097#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080098#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070099#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -0700100#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -0700101#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -0800102#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700103#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -0700104#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800105#include <utility>
Brian Lindahl439afad2022-11-14 11:16:55 -0700106#include <vector>
Dan Stozae77c7662016-05-13 11:37:28 -0700107
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500108#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
ramindani12bfe6b2023-02-03 13:29:19 -0800109#include <aidl/android/hardware/graphics/composer3/RefreshRateChangedDebugData.h>
Lloyd Pique30db6402023-06-26 18:56:51 +0000110#include "Client.h"
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500111
chaviw1d044282017-09-27 12:19:28 -0700112using namespace android::surfaceflinger;
113
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800114namespace android {
115
Lloyd Pique144e1162017-12-20 16:44:52 -0800116class EventThread;
rnleea2ecd832021-07-29 13:58:30 -0700117class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800118class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200119class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -0400120class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700121class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800122class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800123class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700124class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700125class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700126class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200127class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800128class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700129class FrameTracer;
Huihong Luof5029222021-12-16 14:33:46 -0800130class ScreenCapturer;
chaviw60c9d3e2021-06-04 12:52:17 -0500131class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800132
ramindani12bfe6b2023-02-03 13:29:19 -0800133using ::aidl::android::hardware::graphics::composer3::RefreshRateChangedDebugData;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000134using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800135using gui::CaptureArgs;
136using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800137using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800138using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800139using gui::ScreenCaptureResults;
140
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700141namespace frametimeline {
142class FrameTimeline;
143}
144
Chris Ye0783e992020-06-02 21:34:49 -0700145namespace os {
146 class IInputFlinger;
147}
148
Lloyd Pique542307f2018-10-19 13:24:08 -0700149namespace compositionengine {
150class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800151class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800152
153struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700154} // namespace compositionengine
155
Peiyong Lin833074a2018-08-28 11:53:54 -0700156namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800157class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700158} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700159
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800160enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700161 eTransactionNeeded = 0x01,
162 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700163 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700164 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700165 eTransactionFlushNeeded = 0x10,
Patrick Williamsaf06b792023-02-16 17:46:22 -0600166 eInputInfoUpdateNeeded = 0x20,
167 eTransactionMask = 0x3f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800168};
169
Ady Abraham9dada822022-02-03 10:26:59 -0800170// Latch Unsignaled buffer behaviours
171enum class LatchUnsignaledConfig {
172 // All buffers are latched signaled.
173 Disabled,
174
175 // Latch unsignaled is permitted when a single layer is updated in a frame,
176 // and the update includes just a buffer update (i.e. no sync transactions
177 // or geometry changes).
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000178 // Latch unsignaled is also only permitted when a single transaction is ready
179 // to be applied. If we pass an unsignaled fence to HWC, HWC might miss presenting
180 // the frame if the fence does not fire in time. If we apply another transaction,
181 // we may penalize the other transaction unfairly.
Ady Abraham9dada822022-02-03 10:26:59 -0800182 AutoSingleLayer,
183
184 // All buffers are latched unsignaled. This behaviour is discouraged as it
185 // can break sync transactions, stall the display and cause undesired side effects.
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000186 // This is equivalent to ignoring the acquire fence when applying transactions.
Ady Abraham9dada822022-02-03 10:26:59 -0800187 Always,
188};
ramindani4d48f902021-09-20 21:07:45 +0000189
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800190using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800191
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700192class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700193 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700194 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800195 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700196 private ICompositor,
jimmyshiu4e211772023-06-15 15:18:38 +0000197 private scheduler::ISchedulerCallback,
198 private compositionengine::ICEPowerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800199public:
Lloyd Pique30db6402023-06-26 18:56:51 +0000200 struct SkipInitializationTag {};
201
202 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
203 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700204
205 // set main thread scheduling policy
206 static status_t setSchedFifo(bool enabled) ANDROID_API;
207
Wei Wang23aa5a62021-06-04 15:56:57 -0700208 // set main thread scheduling attributes
209 static status_t setSchedAttr(bool enabled);
210
Peiyong Linf243e5e2020-08-22 17:40:59 -0700211 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800212
Lloyd Pique30db6402023-06-26 18:56:51 +0000213 // If fences from sync Framework are supported.
214 static bool hasSyncFramework;
215
216 // The offset in nanoseconds to use when VsyncController timestamps present fence
217 // signaling time.
218 static int64_t dispSyncPresentTimeOffset;
219
220 // Some hardware can do RGB->YUV conversion more efficiently in hardware
221 // controlled by HWC than in hardware controlled by the video encoder.
222 // This instruct VirtualDisplaySurface to use HWC for such conversion on
223 // GL composition.
224 static bool useHwcForRgbToYuv;
225
226 // Controls the number of buffers SurfaceFlinger will allocate for use in
227 // FramebufferSurface
228 static int64_t maxFrameBufferAcquiredBuffers;
229
230 // Controls the minimum acquired buffers SurfaceFlinger will suggest via
231 // ISurfaceComposer.getMaxAcquiredBufferCount().
232 static int64_t minAcquiredBuffers;
233
234 // Controls the maximum width and height in pixels that the graphics pipeline can support for
235 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
236 static uint32_t maxGraphicsWidth;
237 static uint32_t maxGraphicsHeight;
238
Lloyd Pique30db6402023-06-26 18:56:51 +0000239 static bool useContextPriority;
240
241 // The data space and pixel format that SurfaceFlinger expects hardware composer
242 // to composite efficiently. Meaning under most scenarios, hardware composer
243 // will accept layers with the data space and pixel format.
244 static ui::Dataspace defaultCompositionDataspace;
245 static ui::PixelFormat defaultCompositionPixelFormat;
246
247 // The data space and pixel format that SurfaceFlinger expects hardware composer
248 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
249 // hardware composer will accept layers with the data space and pixel format.
250 static ui::Dataspace wideColorGamutCompositionDataspace;
251 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
252
253 static constexpr SkipInitializationTag SkipInitialization;
254
ramindani4d48f902021-09-20 21:07:45 +0000255 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700256
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700257 // must be called before clients can connect
258 void init() ANDROID_API;
259
260 // starts SurfaceFlinger main loop in the current thread
261 void run() ANDROID_API;
262
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700263 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
264 enum class FrameHint { kNone, kActive };
265
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700266 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700267 void scheduleCommit(FrameHint);
268 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700269 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700270 // As above, but also force dirty geometry to repaint.
271 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700272 // Schedule sampling independently from commit or composite.
273 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800274
Lloyd Pique30db6402023-06-26 18:56:51 +0000275 surfaceflinger::Factory& getFactory() { return mFactory; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700276
Lloyd Pique70d91362018-10-18 16:02:55 -0700277 // The CompositionEngine encapsulates all composition related interfaces and actions.
278 compositionengine::CompositionEngine& getCompositionEngine() const;
279
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700280 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700281
Dominik Laskowski75848362019-11-11 17:57:20 -0800282 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700283 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700284 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700285
Robert Carr867be372021-06-29 17:36:02 -0700286 void removeHierarchyFromOffscreenLayers(Layer* layer);
Valerie Hauc5686802019-11-22 14:18:09 -0800287 void removeFromOffscreenLayers(Layer* layer);
288
Vishnu Nair07e2a482022-10-18 19:18:16 +0000289 // Called when all clients have released all their references to
290 // this layer. The layer may still be kept alive by its parents but
291 // the client can no longer modify this layer directly.
292 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);
293
Vishnu Nair3be61902023-04-26 19:47:29 -0700294 std::vector<Layer*> mLayerMirrorRoots;
Robert Carr6a0382d2021-07-01 15:57:17 -0700295
Robert Carr9a803c32021-01-14 16:57:58 -0800296 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
297 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700298 }
299
Lloyd Pique30db6402023-06-26 18:56:51 +0000300 // If set, disables reusing client composition buffers. This can be set by
301 // debug.sf.disable_client_composition_cache
302 bool mDisableClientCompositionCache = false;
303
Alec Mouridea1ac52021-06-23 18:12:18 -0700304 // Disables expensive rendering for all displays
305 // This is scheduled on the main thread
306 void disableExpensiveRendering();
chaviw79468ab2021-10-27 11:11:24 -0500307 FloatRect getMaxDisplayBounds();
Alec Mouridea1ac52021-06-23 18:12:18 -0700308
Vishnu Naira3140382022-02-24 14:07:11 -0800309 // If set, composition engine tries to predict the composition strategy provided by HWC
310 // based on the previous frame. If the strategy can be predicted, gpu composition will
311 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
312 bool mPredictCompositionStrategy = false;
313
Lloyd Pique30db6402023-06-26 18:56:51 +0000314 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
315 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
316 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
317 // on this behavior to increase contrast for some media sources.
318 bool mTreat170mAsSrgb = false;
319
Alec Mouri9af38ba2023-08-16 22:41:14 +0000320 // If true, then screenshots with an enhanced render intent will dim in gamma space.
321 // The purpose is to ensure that screenshots appear correct during system animations for devices
322 // that require that dimming must occur in gamma space.
323 bool mDimInGammaSpaceForEnhancedScreenshots = false;
324
Lloyd Pique30db6402023-06-26 18:56:51 +0000325 // Allows to ignore physical orientation provided through hwc API in favour of
326 // 'ro.surface_flinger.primary_display_orientation'.
327 // TODO(b/246793311): Clean up a temporary property
328 bool mIgnoreHwcPhysicalDisplayOrientation = false;
329
Chavi Weingarten076acac2023-01-19 17:20:43 +0000330 void forceFutureUpdate(int delayInMs);
Vishnu Nair2f65e972023-04-04 16:36:28 +0000331 const DisplayDevice* getDisplayFromLayerStack(ui::LayerStack)
332 REQUIRES(mStateLock, kMainThreadContext);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000333
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400334 // TODO (b/259407931): Remove.
335 // TODO (b/281857977): This should be annotated with REQUIRES(kMainThreadContext), but this
336 // would require thread safety annotations throughout the frontend (in particular Layer and
337 // LayerFE).
338 static ui::Transform::RotationFlags getActiveDisplayRotationFlags() {
339 return sActiveDisplayRotationFlags;
340 }
341
Peiyong Linf243e5e2020-08-22 17:40:59 -0700342protected:
343 // We're reference counted, never destroy SurfaceFlinger directly
344 virtual ~SurfaceFlinger();
345
Dominik Laskowski263eec42021-07-21 23:13:24 -0700346 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
347 REQUIRES(mStateLock);
348
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800349 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000350 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800351
Dominik Laskowski263eec42021-07-21 23:13:24 -0700352 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
353 template <typename Predicate>
354 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
355 return static_cast<bool>(findDisplay(p));
356 }
357
chaviwba4320c2021-09-15 15:20:53 -0500358 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
359 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
360 }
361
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700362private:
David Sodman0c69cad2017-08-21 12:12:51 -0700363 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700364 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800365 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200366 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700367 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700368 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800369 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800370 friend class LayerRenderArea;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700371 friend class SurfaceComposerAIDL;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000372 friend class DisplayRenderArea;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800373
Lloyd Piquef58625d2017-12-19 13:22:33 -0800374 // For unit tests
375 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700376 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700377 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800378
Peiyong Linf243e5e2020-08-22 17:40:59 -0700379 using TransactionSchedule = scheduler::TransactionSchedule;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000380 using GetLayerSnapshotsFunction = std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>;
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700381 using RenderAreaFuture = ftl::Future<std::unique_ptr<RenderArea>>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700382 using DumpArgs = Vector<String16>;
383 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
384
Robert Carr2047fae2016-11-28 14:09:09 -0800385 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800386 public:
chaviwfd462612018-05-31 16:11:27 -0700387 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700388 State& operator=(const State& other) {
389 // We explicitly don't copy stateSet so that, e.g., mDrawingState
390 // always uses the Drawing StateSet.
391 layersSortedByZ = other.layersSortedByZ;
392 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700393 colorMatrixChanged = other.colorMatrixChanged;
394 if (colorMatrixChanged) {
395 colorMatrix = other.colorMatrix;
396 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800397 globalShadowSettings = other.globalShadowSettings;
398
Dan Stoza412903f2017-04-27 13:42:17 -0700399 return *this;
400 }
401
402 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700403 LayerVector layersSortedByZ;
Dominik Laskowski68399272022-09-15 07:54:46 -0700404
405 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
406 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
407
408 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
409 for (size_t i = 0; i < displays.size(); i++) {
410 const auto& state = displays.valueAt(i);
411 if (state.physical && state.physical->id == displayId) {
412 return i;
413 }
414 }
415
416 return {};
417 }
Robert Carr2047fae2016-11-28 14:09:09 -0800418
Chia-I Wu28f320b2018-05-03 11:02:56 -0700419 bool colorMatrixChanged = true;
420 mat4 colorMatrix;
421
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800422 renderengine::ShadowSettings globalShadowSettings;
423
Edgar Arriaga844fa672020-01-16 14:21:42 -0800424 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700425 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
426 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800427 };
428
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800429 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
430 // state before the buffers are latched. The layer owns the atomic counters and decrements the
431 // count in the main thread when dropping or latching a buffer.
432 //
433 // The binder threads increment the same counter when a new transaction containing a buffer is
434 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
435 // This is done to avoid lock contention with the main thread.
436 class BufferCountTracker {
437 public:
438 void increment(BBinder* layerHandle) {
439 std::lock_guard<std::mutex> lock(mLock);
440 auto it = mCounterByLayerHandle.find(layerHandle);
441 if (it != mCounterByLayerHandle.end()) {
442 auto [name, pendingBuffers] = it->second;
443 int32_t count = ++(*pendingBuffers);
444 ATRACE_INT(name.c_str(), count);
445 } else {
446 ALOGW("Handle not found! %p", layerHandle);
447 }
448 }
449
450 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
451 std::lock_guard<std::mutex> lock(mLock);
452 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
453 }
454
455 void remove(BBinder* layerHandle) {
456 std::lock_guard<std::mutex> lock(mLock);
457 mCounterByLayerHandle.erase(layerHandle);
458 }
459
460 private:
461 std::mutex mLock;
462 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
463 mCounterByLayerHandle GUARDED_BY(mLock);
464 };
465
Peiyong Linf243e5e2020-08-22 17:40:59 -0700466 enum class BootStage {
467 BOOTLOADER,
468 BOOTANIMATION,
469 FINISHED,
470 };
471
Peiyong Linf243e5e2020-08-22 17:40:59 -0700472 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
473 static Dumper dumper(F&& dump) {
474 using namespace std::placeholders;
475 return std::bind(std::forward<F>(dump), _3);
476 }
477
478 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
479 Dumper dumper(F dump) {
480 using namespace std::placeholders;
481 return std::bind(dump, this, _3);
482 }
483
484 template <typename F>
485 Dumper argsDumper(F dump) {
486 using namespace std::placeholders;
487 return std::bind(dump, this, _1, _3);
488 }
489
490 template <typename F>
491 Dumper protoDumper(F dump) {
492 using namespace std::placeholders;
493 return std::bind(dump, this, _1, _2, _3);
494 }
495
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700496 // Maximum allowed number of display frames that can be set through backdoor
497 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700498
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700499 static const size_t MAX_LAYERS = 4096;
500
Peiyong Linf243e5e2020-08-22 17:40:59 -0700501 // Implements IBinder.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800502 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
503 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Steven Thomasd4071902020-03-24 16:02:53 -0700504 bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
505 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800506
Peiyong Linf243e5e2020-08-22 17:40:59 -0700507 // Implements ISurfaceComposer
Huihong Luo1768cb02022-10-11 11:10:34 -0700508 sp<IBinder> createDisplay(const String8& displayName, bool secure,
Huihong Luo59a60b72023-03-08 21:44:59 +0000509 float requestedRefreshRate = 0.0f);
Huihong Luo07e72362022-02-14 14:26:04 -0800510 void destroyDisplay(const sp<IBinder>& displayToken);
511 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700512 Mutex::Autolock lock(mStateLock);
513 return getPhysicalDisplayIdsLocked();
514 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700515
Huihong Luo07e72362022-02-14 14:26:04 -0800516 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Pablo Gamito23780be2023-04-18 08:30:00 +0000517 status_t setTransactionState(
518 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& state,
519 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
520 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime,
521 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
522 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
523 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700524 void bootFinished();
Huihong Luo0a81aa32022-02-22 16:02:36 -0800525 virtual status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800526 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700527 gui::ISurfaceComposer::VsyncSource vsyncSource =
528 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
Rachel Lee2248f522023-01-27 16:45:23 -0800529 EventRegistrationFlags eventRegistration = {},
530 const sp<IBinder>& layerHandle = nullptr);
Dominik Laskowskif1833852021-03-23 15:06:50 -0700531
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000532 void captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
533 void captureDisplay(DisplayId, const sp<IScreenCaptureListener>&);
534 void captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700535
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800536 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100537 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800538 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700539 status_t getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo*) EXCLUDES(mStateLock);
540 status_t getDynamicDisplayInfoFromId(int64_t displayId, ui::DynamicDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800541 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700542 status_t getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
543 ui::DynamicDisplayInfo*) EXCLUDES(mStateLock);
544 void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*&, const sp<DisplayDevice>&,
545 const display::DisplaySnapshot&);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800546 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
547 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800548 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700549 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700550 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800551 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
Kriti Dang674b9372022-11-18 10:58:44 +0100552 status_t getHdrConversionCapabilities(
553 std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const;
Kriti Dangd432bb52023-02-09 18:21:04 +0100554 status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
555 int32_t*);
Kriti Dang674b9372022-11-18 10:58:44 +0100556 status_t getHdrOutputConversionSupport(bool* outSupport) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800557 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
558 void setGameContentType(const sp<IBinder>& displayToken, bool on);
559 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100560 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800561 const std::vector<ui::Hdr>& hdrTypes);
Huihong Luo30aa4372022-10-03 14:54:12 -0700562 status_t onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData, bool* success);
Huihong Luo05539a12022-02-23 10:29:40 -0800563 status_t getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers);
Peiyong Linc6780972018-10-28 15:24:08 -0700564 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
565 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800566 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700567 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800568 ui::PixelFormat* outFormat,
569 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800570 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700571 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800572 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700573 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800574 uint64_t timestamp, DisplayedFrameStats* outStats) const;
575 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800576 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800577 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800578 const sp<IRegionSamplingListener>& listener);
579 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
580 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
581 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
582 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
583 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100584 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700585 const gui::DisplayModeSpecs&);
586 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800587 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500588 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800589 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400590 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800591 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400592 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800593 const sp<gui::IHdrLayerInfoListener>& listener);
594 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800595 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800596 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500597 status_t getDisplayDecorationSupport(
598 const sp<IBinder>& displayToken,
599 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800600 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800601 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800602 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700603
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000604 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800605 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700606
Huihong Luo3bdef862022-03-03 11:57:19 -0800607 status_t setOverrideFrameRate(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800608
Tony Huangf3621102023-09-04 17:14:22 +0800609 status_t updateSmallAreaDetection(std::vector<std::pair<int32_t, float>>& uidThresholdMappings);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000610
Tony Huangf3621102023-09-04 17:14:22 +0800611 status_t setSmallAreaDetectionThreshold(int32_t appId, float threshold);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000612
Huihong Luo02186fb2022-02-23 14:21:54 -0800613 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800614
Huihong Luo02186fb2022-02-23 14:21:54 -0800615 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800616
Patrick Williamsacd22582023-07-12 13:47:28 -0500617 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
618 gui::WindowInfosListenerInfo* outResult);
chaviw60c9d3e2021-06-04 12:52:17 -0500619 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800620 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500621
Patrick Williams090ad062023-08-08 12:30:10 -0500622 status_t getStalledTransactionInfo(
623 int pid, std::optional<TransactionHandler::StalledTransactionInfo>& result);
624
Peiyong Linf243e5e2020-08-22 17:40:59 -0700625 // Implements IBinder::DeathRecipient.
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800626 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800627
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700628 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400629 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700630 std::optional<hal::VsyncPeriodNanos>) override;
631 void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) override;
632 void onComposerHalRefresh(hal::HWDisplayId) override;
633 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
634 const hal::VsyncPeriodChangeTimeline&) override;
635 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800636 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
ramindani12bfe6b2023-02-03 13:29:19 -0800637 void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700638
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700639 // ICompositor overrides:
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500640 void configure() override REQUIRES(kMainThreadContext);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400641 bool commit(PhysicalDisplayId pacesetterId, const scheduler::FrameTargets&) override
642 REQUIRES(kMainThreadContext);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500643 CompositeResultsPerDisplay composite(PhysicalDisplayId pacesetterId,
644 const scheduler::FrameTargeters&) override
645 REQUIRES(kMainThreadContext);
646
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700647 void sample() override;
648
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700649 // ISchedulerCallback overrides:
Dominik Laskowski66295432023-03-14 12:25:36 -0400650 void requestHardwareVsync(PhysicalDisplayId, bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400651 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800652 void kernelTimerChanged(bool expired) override;
Ady Abraham62a0be22020-12-08 16:54:10 -0800653 void triggerOnFrameRateOverridesChanged() override;
Ady Abraham822ecbd2023-07-07 16:16:09 -0700654 void onChoreographerAttached() override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700655
jimmyshiu4e211772023-06-15 15:18:38 +0000656 // ICEPowerCallback overrides:
657 void notifyCpuLoadUp() override;
658
Ana Krulecb9afd792020-06-11 13:16:15 -0700659 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
Ady Abraham3efa3942021-06-24 19:01:25 -0700660 void toggleKernelIdleTimer() REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400661
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400662 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400663
ramindani32cf0602022-03-02 02:30:29 +0000664 // Get the controller and timeout that will help decide how the kernel idle timer will be
665 // configured and what value to use as the timeout.
666 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
667 getKernelIdleTimerProperties(DisplayId) REQUIRES(mStateLock);
668 // Updates the kernel idle timer either through HWC or through sysprop
669 // depending on which controller is provided
670 void updateKernelIdleTimer(std::chrono::milliseconds timeoutMs, KernelIdleTimerController,
671 PhysicalDisplayId) REQUIRES(mStateLock);
Ana Krulecb9afd792020-06-11 13:16:15 -0700672 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
673 // make calls to sys prop each time.
674 bool mKernelIdleTimerEnabled = false;
Lloyd Pique30db6402023-06-26 18:56:51 +0000675 // Show spinner with refresh rate overlay
676 bool mRefreshRateOverlaySpinner = false;
677 // Show render rate with refresh rate overlay
678 bool mRefreshRateOverlayRenderRate = false;
679 // Show render rate overlay offseted to the middle of the screen (e.g. for circular displays)
680 bool mRefreshRateOverlayShowInMiddle = false;
Sally Qi147581b2023-06-27 11:55:34 -0700681 // Show hdr sdr ratio overlay
682 bool mHdrSdrRatioOverlay = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700683
Dominik Laskowskifc378b02022-12-02 14:56:05 -0500684 void setDesiredActiveMode(display::DisplayModeRequest&&, bool force = false)
685 REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400686
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700687 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400688
689 void initiateDisplayModeChanges() REQUIRES(mStateLock, kMainThreadContext);
690 void finalizeDisplayModeChange(DisplayDevice&) REQUIRES(mStateLock, kMainThreadContext);
691
Ady Abraham690f4612021-07-01 23:24:03 -0700692 void clearDesiredActiveModeState(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100693 // Called when active mode is no longer is progress
Ady Abraham690f4612021-07-01 23:24:03 -0700694 void desiredActiveModeChangeDone(const sp<DisplayDevice>&) REQUIRES(mStateLock);
Marin Shalamanov5801c942020-12-17 17:00:13 +0100695 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700696 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700697 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800698
Dominik Laskowskif2595442022-08-29 13:51:57 -0700699 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
700 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800701 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400702 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700703
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400704 status_t setDesiredDisplayModeSpecsInternal(
705 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700706 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800707
Dominik Laskowski3f726402022-11-21 17:21:22 -0500708 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
709 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
Dominik Laskowskifc378b02022-12-02 14:56:05 -0500710 const scheduler::RefreshRateSelector&,
711 bool force = false)
Dominik Laskowski3f726402022-11-21 17:21:22 -0500712 REQUIRES(mStateLock, kMainThreadContext);
713
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700714 void commitTransactions() EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
715 void commitTransactionsLocked(uint32_t transactionFlags)
716 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700717 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800718
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700719 // Returns whether a new buffer has been latched.
720 bool latchBuffers();
Dan Stoza28d46a52020-04-28 09:54:54 -0700721
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700722 void updateLayerGeometry();
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000723 void updateLayerMetadataSnapshot();
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000724 std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(
Dominik Laskowski16a345b2023-04-27 17:07:33 -0400725 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000726 void moveSnapshotsFromCompositionArgs(compositionengine::CompositionRefreshArgs& refreshArgs,
Dominik Laskowski16a345b2023-04-27 17:07:33 -0400727 const std::vector<std::pair<Layer*, LayerFE*>>& layers);
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000728 bool updateLayerSnapshotsLegacy(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
729 bool& out) REQUIRES(kMainThreadContext);
730 bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000731 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nairef68d6d2023-02-28 06:18:27 +0000732 void updateLayerHistory(const frontend::LayerSnapshot& snapshot);
Vishnu Nair81750622023-03-08 15:02:06 -0800733 frontend::Update flushLifecycleUpdates() REQUIRES(kMainThreadContext);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800734
Patrick Williams6681c022023-05-15 13:38:16 -0500735 void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime);
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800736 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800737 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
738 std::vector<gui::DisplayInfo>& outDisplayInfos);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800739 void commitInputWindowCommands() REQUIRES(mStateLock);
Riley Andrews03414a12014-07-01 14:22:59 -0700740 void updateCursorAsync();
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700741
Dominik Laskowski59db9562022-10-27 16:18:53 -0400742 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowski14956dc2023-02-22 13:43:57 -0500743
744 void resetPhaseConfiguration(Fps) REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski1c99a002023-01-20 17:10:36 -0500745 void updatePhaseConfiguration(Fps) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800746
Peiyong Linf243e5e2020-08-22 17:40:59 -0700747 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700748 * Transactions
749 */
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000750 bool applyTransactionState(const FrameTimelineInfo& info,
751 std::vector<ResolvedComposerState>& state,
752 Vector<DisplayState>& displays, uint32_t flags,
753 const InputWindowCommands& inputWindowCommands,
754 const int64_t desiredPresentTime, bool isAutoTimestamp,
755 const std::vector<uint64_t>& uncacheBufferIds,
756 const int64_t postTime, bool hasListenerCallbacks,
757 const std::vector<ListenerCallbacks>& listenerCallbacks,
758 int originPid, int originUid, uint64_t transactionId)
759 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700760 // Flush pending transactions that were presented after desiredPresentTime.
Vishnu Nair42ad3192023-01-24 19:17:59 -0800761 // For test only
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700762 bool flushTransactionQueues(VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800763
764 bool applyTransactions(std::vector<TransactionState>&, VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000765 bool applyAndCommitDisplayTransactionStates(std::vector<TransactionState>& transactions)
766 REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800767
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700768 // Returns true if there is at least one transaction that needs to be flushed
769 bool transactionFlushNeeded();
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700770 void addTransactionReadyFilters();
771 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
772 const TransactionHandler::TransactionFlushState& flushState)
773 REQUIRES(kMainThreadContext);
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000774 TransactionHandler::TransactionReadiness transactionReadyBufferCheckLegacy(
775 const TransactionHandler::TransactionFlushState& flushState)
776 REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700777 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
778 const TransactionHandler::TransactionFlushState& flushState)
779 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800780
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000781 uint32_t setClientStateLocked(const FrameTimelineInfo&, ResolvedComposerState&,
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700782 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000783 int64_t postTime, uint64_t transactionId) REQUIRES(mStateLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000784 uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,
785 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000786 int64_t postTime, uint64_t transactionId)
787 REQUIRES(mStateLock);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700788 uint32_t getTransactionFlags() const;
789
Dominik Laskowski94000c42022-03-17 12:55:14 -0700790 // Sets the masked bits, and schedules a commit if needed.
791 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700792 const sp<IBinder>& applyToken = nullptr,
793 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700794
795 // Clears and returns the masked bits.
796 uint32_t clearTransactionFlags(uint32_t mask);
797
chaviw74d90ad2019-04-26 14:45:26 -0700798 void commitOffscreenLayers();
Dominik Laskowski94000c42022-03-17 12:55:14 -0700799
ramindani4d48f902021-09-20 21:07:45 +0000800 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000801 bool shouldLatchUnsignaled(const layer_state_t&, size_t numStates, bool firstTransaction) const;
Vishnu Nair42ad3192023-01-24 19:17:59 -0800802 bool applyTransactionsLocked(std::vector<TransactionState>& transactions, VsyncId)
Vishnu Nair7891e962021-11-11 12:07:21 -0800803 REQUIRES(mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800804 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800805 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
806 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700807 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
808
Peiyong Linf243e5e2020-08-22 17:40:59 -0700809 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700810 * Layer management
811 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000812 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800813
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800814 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
815 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700816
Vishnu Nair84125ac2021-12-02 08:47:48 -0800817 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800818 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700819
Vishnu Nair84125ac2021-12-02 08:47:48 -0800820 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000821 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700822
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000823 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000824 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000825
Josh Gao194ff392022-09-08 16:19:29 -0700826 void markLayerPendingRemovalLocked(const sp<Layer>& layer) REQUIRES(mStateLock);
Mathias Agopiana4912602012-07-12 14:25:33 -0700827
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700828 // add a layer to SurfaceFlinger
Vishnu Nair1391de22023-03-05 19:56:14 -0800829 status_t addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Naircb8be502022-10-12 19:03:23 +0000830 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700831 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700832
Vishnu Nair4351ad52019-02-11 14:13:02 -0800833 // Traverse through all the layers and compute and cache its bounds.
834 void computeLayerBounds();
835
Peiyong Linf243e5e2020-08-22 17:40:59 -0700836 // Boot animation, on/off animations and screen capture
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700837 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700838
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000839 void captureScreenCommon(RenderAreaFuture, GetLayerSnapshotsFunction, ui::Size bufferSize,
840 ui::PixelFormat, bool allowProtected, bool grayscale,
841 const sp<IScreenCaptureListener>&);
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700842 ftl::SharedFuture<FenceResult> captureScreenCommon(
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000843 RenderAreaFuture, GetLayerSnapshotsFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000844 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
845 bool grayscale, const sp<IScreenCaptureListener>&);
Dominik Laskowskib17c6212022-05-09 09:36:19 -0700846 ftl::SharedFuture<FenceResult> renderScreenImpl(
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000847 std::shared_ptr<const RenderArea>, GetLayerSnapshotsFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000848 const std::shared_ptr<renderengine::ExternalTexture>&, bool canCaptureBlackoutContent,
Patrick Williams377c0142022-10-13 17:33:38 +0000849 bool regionSampling, bool grayscale, ScreenCaptureResults&) EXCLUDES(mStateLock)
850 REQUIRES(kMainThreadContext);
chaviw03900772020-08-18 12:34:51 -0700851
chaviw4b9d5e12020-08-04 18:30:35 -0700852 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
853 // matching ownerUid
Ajinkya Chalke02844632023-03-01 12:10:14 +0000854 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid,
855 std::unordered_set<uint32_t> excludeLayerIds,
856 const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700857
Romain Guy11d63f42017-07-20 12:47:14 -0700858 void readPersistentProperties();
859
rnleeed20fa42021-08-10 18:00:03 -0700860 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700861
Peiyong Linf243e5e2020-08-22 17:40:59 -0700862 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700863 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700864 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700865
866 // Called during boot, and restart after system_server death.
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400867 void initializeDisplays() REQUIRES(kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700868
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700869 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
870 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700871 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700872 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700873
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700874 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski80872bd2022-11-15 11:34:33 -0500875 return mDisplays.get(displayToken)
876 .or_else(ftl::static_ref<sp<DisplayDevice>>([] { return nullptr; }))
877 .value();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700878 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700879
Ady Abraham690f4612021-07-01 23:24:03 -0700880 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
881 REQUIRES(mStateLock) {
882 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
883 }
884
885 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
886 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
887 return getDisplayDeviceLocked(token);
888 }
889 return nullptr;
890 }
891
Dominik Laskowski3c363242022-04-07 10:44:12 -0700892 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
893 // TODO(b/182939859): Replace tokens with IDs for display lookup.
894 return findDisplay([id](const auto& display) { return display.getId() == id; });
895 }
896
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500897 std::shared_ptr<compositionengine::Display> getCompositionDisplayLocked(DisplayId id) const
898 REQUIRES(mStateLock) {
899 if (const auto display = getDisplayDeviceLocked(id)) {
900 return display->getCompositionDisplay();
901 }
902 return nullptr;
903 }
904
Dominik Laskowski3c363242022-04-07 10:44:12 -0700905 // Returns the primary display or (for foldables) the active display, assuming that the inner
906 // and outer displays have mutually exclusive power states.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700907 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700908 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700909 }
910
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700911 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -0700912 if (const auto display = getDisplayDeviceLocked(mActiveDisplayId)) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700913 return display;
914 }
Dominik Laskowski3c363242022-04-07 10:44:12 -0700915 // The active display is outdated, so fall back to the primary display.
Dominik Laskowskie591b552022-09-09 10:44:56 -0700916 mActiveDisplayId = getPrimaryDisplayIdLocked();
917 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -0700918 }
919
Ady Abraham3efa3942021-06-24 19:01:25 -0700920 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700921 Mutex::Autolock lock(mStateLock);
922 return getDefaultDisplayDeviceLocked();
923 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200924
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700925 using DisplayDeviceAndSnapshot =
926 std::pair<sp<DisplayDevice>, display::PhysicalDisplay::SnapshotRef>;
927
928 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
929 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
930 return [this](const display::PhysicalDisplay& display) REQUIRES(
931 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
932 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
933 return std::make_pair(std::move(device), display.snapshotRef());
934 }
935
936 return {};
937 };
938 }
939
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700940 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
941 template <typename Predicate>
942 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
943 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
Dominik Laskowski3de67272023-08-09 13:15:31 -0400944 [&](const auto& pair)
945 REQUIRES(mStateLock) { return p(*pair.second); });
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700946
947 return it == mDisplays.end() ? nullptr : it->second;
948 }
949
Ady Abrahamed3290f2021-05-17 15:12:14 -0700950 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
951
Mathias Agopian87baae12012-07-31 12:38:26 -0700952 // mark a region of a layer stack dirty. this updates the dirty
953 // region of all screens presenting this layer stack.
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000954 void invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700955
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700956 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
957 REQUIRES(mStateLock) {
958 return {layerStack,
959 PhysicalDisplayId::tryCast(displayId)
960 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
961 .transform(&display::PhysicalDisplay::isInternal)
962 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -0700963 }
964
Peiyong Linf243e5e2020-08-22 17:40:59 -0700965 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700966 * H/W composer
967 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100968 // The following thread safety rules apply when accessing HWComposer:
969 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
970 // acquire mStateLock.
971 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -0700972 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +0100973 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -0700974 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700975
Peiyong Linf243e5e2020-08-22 17:40:59 -0700976 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700977 * Compositing
978 */
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500979 void postComposition(PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters&,
980 nsecs_t presentStartTime) REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -0700981
Peiyong Linf243e5e2020-08-22 17:40:59 -0700982 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -0700983 * Display management
984 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800985 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
986 REQUIRES(mStateLock);
987
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700988 // TODO(b/241285876): Move to DisplayConfigurator.
989 //
990 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
991 // commit display transactions.
992 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
993 EXCLUDES(mHotplugMutex);
994
Dominik Laskowskibb66e632022-08-17 08:00:25 -0700995 // Returns a string describing the hotplug, or nullptr if it was rejected.
996 const char* processHotplug(PhysicalDisplayId, hal::HWDisplayId, bool connected,
997 DisplayIdentificationInfo&&) REQUIRES(mStateLock)
998 REQUIRES(kMainThreadContext);
999
Lloyd Pique542307f2018-10-19 13:24:08 -07001000 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07001001 const wp<IBinder>& displayToken,
1002 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -07001003 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +01001004 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001005 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001006 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001007 void processDisplayRemoved(const wp<IBinder>& displayToken)
1008 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +01001009 void processDisplayChanged(const wp<IBinder>& displayToken,
1010 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001011 const DisplayDeviceState& drawingState)
1012 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001013
Dominik Laskowskifdac5652023-06-29 12:01:13 -04001014 void dispatchDisplayHotplugEvent(PhysicalDisplayId, bool connected);
1015 void dispatchDisplayModeChangeEvent(PhysicalDisplayId, const scheduler::FrameRateMode&)
1016 REQUIRES(mStateLock);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08001017
Peiyong Linf243e5e2020-08-22 17:40:59 -07001018 /*
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001019 * VSYNC
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001020 */
Ady Abraham2492a022020-07-24 11:09:55 -07001021 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001022
Dominik Laskowskic2867142019-01-21 11:33:38 -08001023 /*
1024 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001025 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001026 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +02001027 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001028 return mPhysicalDisplays.get(displayId)
1029 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
Dominik Laskowski80872bd2022-11-15 11:34:33 -05001030 .or_else([] { return std::optional<sp<display::DisplayToken>>(nullptr); })
1031 .value();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001032 }
1033
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001034 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001035 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001036
Dominik Laskowski3c363242022-04-07 10:44:12 -07001037 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001038 //
Dominik Laskowski3c363242022-04-07 10:44:12 -07001039 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
1040 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
1041 // display because SF does not support disconnecting it, though in practice HWC may circumvent
1042 // this limitation.)
1043 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
1044 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001045 }
1046
Dominik Laskowski3c363242022-04-07 10:44:12 -07001047 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001048 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001049 }
1050
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001051 // Toggles use of HAL/GPU virtual displays.
1052 void enableHalVirtualDisplays(bool);
1053
1054 // Virtual display lifecycle for ID generation and HAL allocation.
Dominik Laskowski263eec42021-07-21 23:13:24 -07001055 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat) REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001056 void releaseVirtualDisplay(VirtualDisplayId);
1057
Dominik Laskowski3de67272023-08-09 13:15:31 -04001058 // Returns a display other than `mActiveDisplayId` that can be activated, if any.
1059 sp<DisplayDevice> getActivatableDisplay() const REQUIRES(mStateLock, kMainThreadContext);
1060
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001061 void onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
1062 const DisplayDevice& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001063 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001064
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001065 void onActiveDisplaySizeChanged(const DisplayDevice&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001066
Dominik Laskowskic2867142019-01-21 11:33:38 -08001067 /*
1068 * Debugging & dumpsys
1069 */
Alec Mouri67617332022-09-26 21:37:01 +00001070 void dumpAllLocked(const DumpArgs& args, const std::string& compositionLayers,
1071 std::string& result) const REQUIRES(mStateLock);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00001072 void dumpHwcLayersMinidump(std::string& result) const REQUIRES(mStateLock, kMainThreadContext);
1073 void dumpHwcLayersMinidumpLockedLegacy(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001074
1075 void appendSfConfigString(std::string& result) const;
1076 void listLayersLocked(std::string& result) const;
1077 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
1078 void clearStatsLocked(const DumpArgs& args, std::string& result);
1079 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001080 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001081 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001082
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001083 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1084 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1085 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001086
1087 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1088 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001089 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001090 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001091 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
John Reck2a3d29d2023-08-17 17:45:01 -04001092 void dumpHdrInfo(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001093
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001094 perfetto::protos::LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
1095 void dumpOffscreenLayersProto(perfetto::protos::LayersProto& layersProto,
Vishnu Nair00b90132021-11-05 14:03:40 -07001096 uint32_t traceFlags = LayerTracing::TRACE_ALL) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001097 google::protobuf::RepeatedPtrField<perfetto::protos::DisplayProto> dumpDisplayProto() const;
Kean Mariotti639b54f2023-04-20 12:06:29 +00001098 void doActiveLayersTracingIfNeeded(bool isCompositionComputed, bool visibleRegionDirty,
1099 TimePoint, VsyncId) REQUIRES(kMainThreadContext);
1100 perfetto::protos::LayersSnapshotProto takeLayersSnapshotProto(uint32_t flags, TimePoint,
1101 VsyncId, bool visibleRegionDirty)
Vishnu Nair81750622023-03-08 15:02:06 -08001102 REQUIRES(kMainThreadContext);
chaviw0a398992021-08-13 10:13:01 -05001103
Alec Mouri6b9e9912020-01-21 10:50:24 -08001104 // Dumps state from HW Composer
1105 void dumpHwc(std::string& result) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001106 perfetto::protos::LayersProto dumpProtoFromMainThread(
1107 uint32_t traceFlags = LayerTracing::TRACE_ALL) EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001108 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001109 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001110
Dominik Laskowskic2867142019-01-21 11:33:38 -08001111 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1112
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001113 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001114
1115 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1116 return doDump(fd, args, asProto);
1117 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001118
chaviw17ac24b2021-01-28 18:50:05 -08001119 static mat4 calculateColorMatrix(float saturation);
1120
Chia-I Wu28f320b2018-05-03 11:02:56 -07001121 void updateColorMatrixLocked();
1122
Peiyong Linf243e5e2020-08-22 17:40:59 -07001123 // Verify that transaction is being called by an approved process:
1124 // either AID_GRAPHICS or AID_SYSTEM.
1125 status_t CheckTransactCodeCredentials(uint32_t code);
1126
Ady Abrahame46243a2021-02-23 19:33:49 -08001127 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001128
Peiyong Linf243e5e2020-08-22 17:40:59 -07001129 /*
1130 * Generic Layer Metadata
1131 */
1132 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1133
Lloyd Pique30db6402023-06-26 18:56:51 +00001134 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1135 std::chrono::nanoseconds presentLatency);
Ady Abraham899dcdb2021-06-15 16:56:21 -07001136 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001137
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00001138 bool isHdrLayer(const frontend::LayerSnapshot& snapshot) const;
John Reck49d9ad32022-02-23 19:03:31 -05001139
ramindani06e518e2022-03-14 18:47:53 +00001140 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1141 REQUIRES(mStateLock);
Vishnu Naird47bcee2023-02-24 18:08:51 +00001142 void traverseLegacyLayers(const LayerVector::Visitor& visitor) const;
Vishnu Nair8c5b7002023-08-17 21:03:57 -07001143 void initTransactionTraceWriter();
Peiyong Linf243e5e2020-08-22 17:40:59 -07001144 sp<StartPropertySetThread> mStartPropertySetThread;
Lloyd Pique30db6402023-06-26 18:56:51 +00001145 surfaceflinger::Factory& mFactory;
1146 pid_t mPid;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001147 std::future<void> mRenderEnginePrimeCacheFuture;
1148
Leon Scroggins III67388622023-02-06 20:36:20 -05001149 // mStateLock has conventions related to the current thread, because only
1150 // the main thread should modify variables protected by mStateLock.
1151 // - read access from a non-main thread must lock mStateLock, since the main
1152 // thread may modify these variables.
1153 // - write access from a non-main thread is not permitted.
1154 // - read access from the main thread can use an ftl::FakeGuard, since other
1155 // threads must not modify these variables.
1156 // - write access from the main thread must lock mStateLock, since another
1157 // thread may be reading these variables.
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001158 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001159 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001160 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001161 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001162 SortedVector<sp<Layer>> mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001163
Brian Lindahl439afad2022-11-14 11:16:55 -07001164 // Buffers that have been discarded by clients and need to be evicted from per-layer caches so
1165 // the graphics memory can be immediately freed.
1166 std::vector<uint64_t> mBufferIdsToUncache;
1167
Chia-I Wu28f320b2018-05-03 11:02:56 -07001168 // global color transform states
1169 Daltonizer mDaltonizer;
1170 float mGlobalSaturationFactor = 1.0f;
1171 mat4 mClientColorMatrix;
1172
Lloyd Pique30db6402023-06-26 18:56:51 +00001173 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
1174 // If there are more GraphicBufferProducers tracked by SurfaceFlinger than
1175 // this threshold, then begin logging.
1176 size_t mGraphicBufferProducerListSizeLogThreshold =
1177 static_cast<size_t>(0.95 * static_cast<double>(MAX_LAYERS));
1178
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001179 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001180 bool mLayersRemoved = false;
1181 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001182
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001183 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001184 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001185
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001186 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001187 const nsecs_t mBootTime = systemTime();
Lloyd Pique30db6402023-06-26 18:56:51 +00001188 bool mIsUserBuild = true;
Mathias Agopian3094df32012-06-18 18:06:45 -07001189
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001190 // Can only accessed from the main thread, these members
1191 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001192 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001193 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001194
John Reck68796592023-01-25 13:47:12 -05001195 bool mHdrLayerInfoChanged = false;
1196
Robert Carr167bdde2021-07-28 11:26:51 -07001197 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1198 // scene hasn't changed
1199 bool mAddingHDRLayerInfoListener = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00001200 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001201
Robert Carre450fb52021-06-11 13:21:09 -07001202 // Set during transaction application stage to track if the input info or children
1203 // for a layer has changed.
1204 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001205 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001206 bool mSomeChildrenChanged;
Robert Carrb552ff52021-06-11 13:35:54 -07001207 bool mForceTransactionDisplayChange = false;
Ady Abraham822ecbd2023-07-07 16:16:09 -07001208 bool mUpdateAttachedChoreographer = false;
Robert Carre450fb52021-06-11 13:21:09 -07001209
Vishnu Nair0a4fb002022-08-08 02:40:42 +00001210 // Set if LayerMetadata has changed since the last LayerMetadata snapshot.
1211 bool mLayerMetadataSnapshotNeeded = false;
1212
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001213 // TODO(b/238781169) validate these on composition
Alec Mouri5c9c9602020-09-01 15:10:40 -07001214 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001215 // latched.
Huihong Luoa339d0a2022-02-05 09:42:42 -08001216 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithQueuedFrames;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001217 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;
Vishnu Nair6f209e22023-08-04 16:33:23 +00001218 std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;
1219
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001220 // Tracks layers that need to update a display's dirty region.
1221 std::vector<sp<Layer>> mLayersPendingRefresh;
Vishnu Nair802ac4f2023-05-10 13:55:22 -07001222 // Sorted list of layers that were composed during previous frame. This is used to
1223 // avoid an expensive traversal of the layer hierarchy when there are no
1224 // visible region changes. Because this is a list of strong pointers, this will
1225 // extend the life of the layer but this list is only updated in the main thread.
1226 std::vector<sp<Layer>> mPreviouslyComposedLayers;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001227
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001228 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001229
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001230 struct HotplugEvent {
1231 hal::HWDisplayId hwcDisplayId;
1232 hal::Connection connection = hal::Connection::INVALID;
1233 };
1234
1235 std::mutex mHotplugMutex;
1236 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001237
Dominik Laskowskieb627312022-04-07 09:13:16 -07001238 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1239 // never removed, so take precedence over external and virtual displays.
1240 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001241 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001242 ui::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001243
1244 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001245
Dominik Laskowskie591b552022-09-09 10:44:56 -07001246 // The inner or outer display for foldables, assuming they have mutually exclusive power states.
Dominik Laskowskifc378b02022-12-02 14:56:05 -05001247 // Atomic because writes from onActiveDisplayChangedLocked are not always under mStateLock, but
1248 // reads from ISchedulerCallback::requestDisplayModes may happen concurrently.
1249 std::atomic<PhysicalDisplayId> mActiveDisplayId GUARDED_BY(mStateLock);
Dominik Laskowskie591b552022-09-09 10:44:56 -07001250
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001251 struct {
1252 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1253 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1254 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001255
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001256 std::atomic_uint mDebugFlashDelay = 0;
1257 std::atomic_bool mDebugDisableHWC = false;
1258 std::atomic_bool mDebugDisableTransformHint = false;
1259 std::atomic<nsecs_t> mDebugInTransaction = 0;
1260 std::atomic_bool mForceFullDamage = false;
1261
Lloyd Pique30db6402023-06-26 18:56:51 +00001262 bool mLayerCachingEnabled = false;
1263 bool mBackpressureGpuComposition = false;
1264
Vishnu Nair81750622023-03-08 15:02:06 -08001265 LayerTracing mLayerTracing;
Dominik Laskowski46471e62022-01-14 15:34:03 -08001266 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001267
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001268 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001269 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001270 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001271
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001272 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001273
Lloyd Pique30db6402023-06-26 18:56:51 +00001274 // If blurs should be enabled on this device.
1275 bool mSupportsBlur = false;
1276
Robert Carr9a803c32021-01-14 16:57:58 -08001277 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001278
chaviweadf0d42019-08-12 13:28:29 -07001279 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001280
Steven Morelanda904bb92019-07-02 17:37:23 -07001281 // to linkToDeath
1282 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001283 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1284 // different threads without a lock and could trigger unsynchronized writes to
1285 // to mWindowManager or mInputFlinger
1286 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001287
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001288 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001289
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001290 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001291
Peiyong Lina3ea5592019-02-10 14:45:00 -08001292 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1293 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1294 // 2. be one of the supported color modes returned by hardware composer, otherwise
1295 // it will not be respected.
1296 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1297 // is not set to 1.
1298 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1299 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1300
Lloyd Pique30db6402023-06-26 18:56:51 +00001301 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1302 // If false, wide color modes are filtered out for all internal displays.
1303 bool mSupportsWideColor = false;
Dominik Laskowski788945b2022-08-30 12:10:56 -07001304
Lloyd Pique30db6402023-06-26 18:56:51 +00001305 ui::Dataspace mDefaultCompositionDataspace;
1306 ui::Dataspace mWideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001307
Patrick Williams0a525a42022-10-26 20:20:50 +00001308 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Chavi Weingarten076acac2023-01-19 17:20:43 +00001309 std::atomic<int> mNumTrustedPresentationListeners = 0;
1310
Lloyd Pique70d91362018-10-18 16:02:55 -07001311 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001312
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05001313 CompositionCoveragePerDisplay mCompositionCoverage;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001314
Garfield Tan9c9c1912021-07-19 12:02:16 -07001315 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1316 // any mutex.
1317 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001318
Lloyd Pique30db6402023-06-26 18:56:51 +00001319 const std::string mHwcServiceName;
1320
Peiyong Linf243e5e2020-08-22 17:40:59 -07001321 /*
Ana Krulecb43429d2019-01-09 14:28:51 -08001322 * Scheduler
1323 */
Dominik Laskowski068173d2021-08-11 17:22:59 -07001324 std::unique_ptr<scheduler::Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001325 scheduler::ConnectionHandle mAppConnectionHandle;
1326 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001327
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001328 // Stores phase offsets configured per refresh rate.
Ady Abraham8287e852020-08-12 14:44:58 -07001329 std::unique_ptr<scheduler::VsyncConfiguration> mVsyncConfiguration;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001330
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001331 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Dominik Laskowski80c77272022-07-08 12:47:29 -07001332 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001333
Lloyd Pique30db6402023-06-26 18:56:51 +00001334 bool mLumaSampling = true;
Kevin DuBois413287f2019-02-25 08:46:47 -08001335 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001336 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001337 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Lloyd Pique30db6402023-06-26 18:56:51 +00001338 ui::DisplayPrimaries mInternalDisplayPrimaries;
1339
1340 const float mEmulatedDisplayDensity;
1341 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001342
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001343 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001344 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001345 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001346
Xiang Wang839fe5b2022-04-04 17:39:38 +00001347 std::unique_ptr<Hwc2::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001348
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001349 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001350
Sally Qi147581b2023-06-27 11:55:34 -07001351 void enableHdrSdrRatioOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
1352
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001353 // Flag used to set override desired display mode from backdoor
1354 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001355
1356 // A set of layers that have no parent so they are not drawn on screen.
1357 // Should only be accessed by the main thread.
1358 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1359 // be any issues with a raw pointer referencing an invalid object.
1360 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001361
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001362 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001363
1364 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1365 GUARDED_BY(mStateLock);
John Reck68796592023-01-25 13:47:12 -05001366
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001367 mutable std::mutex mCreatedLayersLock;
arthurhungdba591c2021-02-08 17:28:49 +08001368
1369 // A temporay pool that store the created layers and will be added to current state in main
1370 // thread.
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001371 std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001372 bool commitCreatedLayers(VsyncId, std::vector<LayerCreatedState>& createdLayers);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001373 void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001374
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001375 mutable std::mutex mMirrorDisplayLock;
1376 struct MirrorDisplayState {
1377 MirrorDisplayState(ui::LayerStack layerStack, sp<IBinder>& rootHandle,
1378 const sp<Client>& client)
1379 : layerStack(layerStack), rootHandle(rootHandle), client(client) {}
1380
1381 ui::LayerStack layerStack;
1382 sp<IBinder> rootHandle;
1383 const sp<Client> client;
1384 };
1385 std::vector<MirrorDisplayState> mMirrorDisplays GUARDED_BY(mMirrorDisplayLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001386 bool commitMirrorDisplays(VsyncId);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001387
Ady Abraham1273ac12021-08-26 17:31:53 -07001388 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001389
Leon Scroggins III85d4b222023-05-09 13:58:18 -04001390 // Must only be accessed on the main thread.
1391 // TODO (b/259407931): Remove.
1392 static ui::Transform::RotationFlags sActiveDisplayRotationFlags;
1393
Ady Abraham1b11bc62021-06-03 19:51:19 -07001394 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001395 return hasDisplay(
1396 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001397 }
Sally Qi147581b2023-06-27 11:55:34 -07001398 bool isHdrSdrRatioOverlayEnabled() const REQUIRES(mStateLock) {
1399 return hasDisplay(
1400 [](const auto& display) { return display.isHdrSdrRatioOverlayEnabled(); });
1401 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001402 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00001403 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1404 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
1405 snapshotFilterFn);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001406 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Ajinkya Chalke02844632023-03-01 12:10:14 +00001407 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1408 std::unordered_set<uint32_t> excludeLayerIds);
1409 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001410 uint32_t rootLayerId, uint32_t uid, std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07001411 bool childrenOnly, const std::optional<FloatRect>& optionalParentCrop);
Ady Abraham1b11bc62021-06-03 19:51:19 -07001412
chaviw60c9d3e2021-06-04 12:52:17 -05001413 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001414
Robert Carr9b623c32022-03-21 15:55:22 -07001415 FlagManager mFlagManager;
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001416
1417 // returns the framerate of the layer with the given sequence ID
1418 float getLayerFramerate(nsecs_t now, int32_t id) const {
1419 return mScheduler->getLayerFramerate(now, id);
1420 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001421
Matt Buckley50c44062022-01-17 20:48:10 +00001422 bool mPowerHintSessionEnabled;
1423
Lloyd Pique30db6402023-06-26 18:56:51 +00001424 bool mLayerLifecycleManagerEnabled = false;
1425 bool mLegacyFrontEndEnabled = true;
1426
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001427 frontend::LayerLifecycleManager mLayerLifecycleManager;
1428 frontend::LayerHierarchyBuilder mLayerHierarchyBuilder{{}};
1429 frontend::LayerSnapshotBuilder mLayerSnapshotBuilder;
1430
Vishnu Nair606d9d02023-08-19 14:20:18 -07001431 std::vector<std::pair<uint32_t, std::string>> mDestroyedHandles;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001432 std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers;
Vishnu Nair81750622023-03-08 15:02:06 -08001433 std::vector<LayerCreationArgs> mNewLayerArgs;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001434 // These classes do not store any client state but help with managing transaction callbacks
1435 // and stats.
1436 std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers;
Ady Abrahame9ebce02022-02-03 12:05:06 -08001437
Vishnu Nair59f6d2d2022-10-05 16:59:56 -07001438 TransactionHandler mTransactionHandler;
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001439 ui::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos;
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001440 bool mFrontEndDisplayInfosChanged = false;
Patrick Williams1caf3b72023-03-31 10:59:10 -05001441
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05001442 // WindowInfo ids visible during the last commit.
1443 std::unordered_set<int32_t> mVisibleWindowIds;
Brian Johnson51d8d5d2023-07-28 10:18:47 -07001444
1445 // Mirroring
1446 // Map of displayid to mirrorRoot
1447 ftl::SmallMap<int64_t, sp<SurfaceControl>, 3> mMirrorMapForDebug;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001448
1449 void sfdo_enableRefreshRateOverlay(bool active);
1450 void sfdo_setDebugFlash(int delay);
1451 void sfdo_scheduleComposite();
1452 void sfdo_scheduleCommit();
Huihong Luof5029222021-12-16 14:33:46 -08001453};
1454
1455class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1456public:
Greg Kaisera5628662022-02-28 07:18:04 -08001457 SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001458
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001459 binder::Status bootFinished() override;
1460 binder::Status createDisplayEventConnection(
1461 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08001462 const sp<IBinder>& layerHandle,
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001463 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001464 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001465 binder::Status createDisplay(const std::string& displayName, bool secure,
Huihong Luo1768cb02022-10-11 11:10:34 -07001466 float requestedRefreshRate, sp<IBinder>* outDisplay) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001467 binder::Status destroyDisplay(const sp<IBinder>& display) override;
1468 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001469 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001470 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001471 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001472 binder::Status getDisplayStats(const sp<IBinder>& display,
1473 gui::DisplayStatInfo* outStatInfo) override;
1474 binder::Status getDisplayState(const sp<IBinder>& display,
1475 gui::DisplayState* outState) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001476 binder::Status getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08001477 gui::StaticDisplayInfo* outInfo) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001478 binder::Status getDynamicDisplayInfoFromId(int64_t displayId,
1479 gui::DynamicDisplayInfo* outInfo) override;
1480 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
1481 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001482 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1483 gui::DisplayPrimaries* outPrimaries) override;
1484 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1485 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001486 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1487 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001488 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001489 binder::Status getHdrConversionCapabilities(
1490 std::vector<gui::HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +01001491 binder::Status setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
1492 int32_t*) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001493 binder::Status getHdrOutputConversionSupport(bool* outSupport) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001494 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1495 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001496 binder::Status captureDisplay(const DisplayCaptureArgs&,
1497 const sp<IScreenCaptureListener>&) override;
1498 binder::Status captureDisplayById(int64_t, const sp<IScreenCaptureListener>&) override;
1499 binder::Status captureLayers(const LayerCaptureArgs&,
1500 const sp<IScreenCaptureListener>&) override;
Dominik Laskowski66296b22022-07-12 08:20:36 -07001501
1502 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001503 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1504 return binder::Status::ok();
1505 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001506 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001507 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001508 }
1509
Huihong Luo05539a12022-02-23 10:29:40 -08001510 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1511 const std::vector<int32_t>& hdrTypes) override;
1512 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001513 binder::Status getLayerDebugInfo(std::vector<gui::LayerDebugInfo>* outLayers) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001514 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1515 binder::Status getDisplayedContentSamplingAttributes(
1516 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1517 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1518 int8_t componentMask,
1519 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001520 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1521 int64_t timestamp,
1522 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001523 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001524 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1525 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001526 binder::Status addRegionSamplingListener(
1527 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1528 const sp<gui::IRegionSamplingListener>& listener) override;
1529 binder::Status removeRegionSamplingListener(
1530 const sp<gui::IRegionSamplingListener>& listener) override;
1531 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1532 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1533 binder::Status addTunnelModeEnabledListener(
1534 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1535 binder::Status removeTunnelModeEnabledListener(
1536 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001537 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1538 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001539 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1540 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001541 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1542 bool* outSupport) override;
1543 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1544 const gui::DisplayBrightness& brightness) override;
1545 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1546 const sp<gui::IHdrLayerInfoListener>& listener) override;
1547 binder::Status removeHdrLayerInfoListener(
1548 const sp<IBinder>& displayToken,
1549 const sp<gui::IHdrLayerInfoListener>& listener) override;
John Reck68796592023-01-25 13:47:12 -05001550
Huihong Luo37396db2022-02-15 10:43:00 -08001551 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001552 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1553 const gui::Color& spotColor, float lightPosY,
1554 float lightPosZ, float lightRadius) override;
1555 binder::Status getDisplayDecorationSupport(
1556 const sp<IBinder>& displayToken,
1557 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
1558 binder::Status setOverrideFrameRate(int32_t uid, float frameRate) override;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001559 binder::Status enableRefreshRateOverlay(bool active) override;
1560 binder::Status setDebugFlash(int delay) override;
1561 binder::Status scheduleComposite() override;
1562 binder::Status scheduleCommit() override;
Tony Huangf3621102023-09-04 17:14:22 +08001563 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00001564 const std::vector<float>& thresholds) override;
Tony Huangf3621102023-09-04 17:14:22 +08001565 binder::Status setSmallAreaDetectionThreshold(int32_t appId, float threshold) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001566 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1567 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
Patrick Williamsacd22582023-07-12 13:47:28 -05001568 binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
1569 gui::WindowInfosListenerInfo* outInfo) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001570 binder::Status removeWindowInfosListener(
1571 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Patrick Williams090ad062023-08-08 12:30:10 -05001572 binder::Status getStalledTransactionInfo(int pid,
1573 std::optional<gui::StalledTransactionInfo>* outInfo);
Huihong Luof5029222021-12-16 14:33:46 -08001574
1575private:
Huihong Luo07e72362022-02-14 14:26:04 -08001576 static const constexpr bool kUsePermissionCache = true;
1577 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001578 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001579 status_t checkReadFrameBufferPermission();
Sally Qi6bb12822022-10-05 11:42:30 -07001580 static void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
1581 gui::DynamicDisplayInfo*& outInfo);
Huihong Luo07e72362022-02-14 14:26:04 -08001582
1583private:
Huihong Luof5029222021-12-16 14:33:46 -08001584 sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001585};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001586
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001587} // namespace android