blob: cbd47bc22edf470e7b76a8556a1c5f3558103d50 [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
Vishnu Naird7ff85f2023-12-08 09:51:31 -080024#include <android-base/stringprintf.h>
25#include <android-base/strings.h>
Dominik Laskowski83b88212018-12-11 13:34:06 -080026#include <android-base/thread_annotations.h>
Huihong Luof5029222021-12-16 14:33:46 -080027#include <android/gui/BnSurfaceComposer.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080028#include <android/gui/DisplayStatInfo.h>
29#include <android/gui/DisplayState.h>
Pascal Mütschardd56514e2024-05-24 17:37:13 +020030#include <android/gui/IJankListener.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080031#include <android/gui/ISurfaceComposerClient.h>
Vishnu Nairbe0ad902024-06-27 23:38:43 +000032#include <common/trace.h>
Steven Moreland2716e112018-02-23 14:57:20 -080033#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080034#include <cutils/compiler.h>
Dominik Laskowski80872bd2022-11-15 11:34:33 -050035#include <ftl/algorithm.h>
Dominik Laskowskib17c6212022-05-09 09:36:19 -070036#include <ftl/future.h>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040037#include <ftl/non_null.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080038#include <gui/BufferQueue.h>
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -070039#include <gui/CompositorTiming.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080040#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080041#include <gui/ISurfaceComposer.h>
Huihong Luoffee3bc2023-01-17 16:14:35 +000042#include <gui/ITransactionCompletedListener.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070043#include <gui/LayerState.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080044#include <layerproto/LayerProtoHeader.h>
45#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080046#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070047#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070048#include <system/graphics.h>
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050049#include <ui/DisplayMap.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080050#include <ui/FenceTime.h>
51#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010052#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080053#include <utils/Errors.h>
54#include <utils/KeyedVector.h>
55#include <utils/RefBase.h>
56#include <utils/SortedVector.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080057#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070058
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080059#include <compositionengine/OutputColorSetting.h>
Matt Buckley18b93522024-08-27 05:30:18 +000060#include <compositionengine/impl/OutputCompositionState.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080061#include <scheduler/Fps.h>
Dominik Laskowski80c77272022-07-08 12:47:29 -070062#include <scheduler/PresentLatencyTracker.h>
Dominik Laskowski8792c112022-07-12 09:03:39 -070063#include <scheduler/Time.h>
Dominik Laskowski1c99a002023-01-20 17:10:36 -050064#include <scheduler/TransactionSchedule.h>
Dominik Laskowski63f12792023-01-21 16:58:22 -050065#include <scheduler/interface/CompositionCoverage.h>
66#include <scheduler/interface/ICompositor.h>
Patrick Williams2e9748f2022-08-09 22:48:18 +000067#include <ui/FenceResult.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080068
Alec Mouri9b133ca2023-11-14 19:00:01 +000069#include <common/FlagManager.h>
Dominik Laskowski6e465152022-09-28 11:00:25 -040070#include "Display/DisplayModeController.h"
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070071#include "Display/PhysicalDisplay.h"
Gil Dekel5d660422024-10-25 16:20:13 -040072#include "Display/VirtualDisplaySnapshot.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070073#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080074#include "DisplayHardware/HWC2.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020075#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080076#include "Effects/Daltonizer.h"
Vishnu Nairaf6d2972022-11-18 06:26:38 +000077#include "FrontEnd/DisplayInfo.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000078#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000079#include "FrontEnd/LayerLifecycleManager.h"
Vishnu Nair7aa0eb72023-01-24 03:59:27 +000080#include "FrontEnd/LayerSnapshot.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000081#include "FrontEnd/LayerSnapshotBuilder.h"
Vishnu Naira61e4fb2022-10-18 18:29:37 +000082#include "FrontEnd/TransactionHandler.h"
Robert Carr2047fae2016-11-28 14:09:09 -080083#include "LayerVector.h"
Vishnu Naird7ff85f2023-12-08 09:51:31 -080084#include "MutexUtils.h"
Matt Buckley18b93522024-08-27 05:30:18 +000085#include "PowerAdvisor/PowerAdvisor.h"
Leon Scroggins IIIc275df42023-02-07 16:40:21 -050086#include "Scheduler/ISchedulerCallback.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040087#include "Scheduler/RefreshRateSelector.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070088#include "Scheduler/Scheduler.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080089#include "SurfaceFlingerFactory.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -080090#include "ThreadContext.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070091#include "Tracing/LayerTracing.h"
Vishnu Nair7891e962021-11-11 12:07:21 -080092#include "Tracing/TransactionTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080093#include "TransactionCallbackInvoker.h"
Vishnu Nair6b591152021-10-08 11:45:14 -070094#include "TransactionState.h"
Dominik Laskowskid4a22752024-03-08 17:39:04 -050095#include "Utils/OnceFuture.h"
Mathias Agopian86303202012-07-24 22:46:10 -070096
Dominik Laskowski83b88212018-12-11 13:34:06 -080097#include <atomic>
98#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080099#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -0700100#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -0800101#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800102#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700103#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800104#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700105#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -0700106#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -0700107#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -0800108#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700109#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -0700110#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800111#include <utility>
Brian Lindahl439afad2022-11-14 11:16:55 -0700112#include <vector>
Dan Stozae77c7662016-05-13 11:37:28 -0700113
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500114#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Huihong Luo791bef92023-09-19 21:18:45 -0700115#include <aidl/android/hardware/graphics/common/DisplayHotplugEvent.h>
ramindani12bfe6b2023-02-03 13:29:19 -0800116#include <aidl/android/hardware/graphics/composer3/RefreshRateChangedDebugData.h>
Lloyd Pique30db6402023-06-26 18:56:51 +0000117#include "Client.h"
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500118
chaviw1d044282017-09-27 12:19:28 -0700119using namespace android::surfaceflinger;
120
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800121namespace android {
122
Lloyd Pique144e1162017-12-20 16:44:52 -0800123class EventThread;
rnleea2ecd832021-07-29 13:58:30 -0700124class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800125class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200126class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -0400127class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700128class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800129class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800130class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700131class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700132class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700133class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200134class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800135class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700136class FrameTracer;
Huihong Luof5029222021-12-16 14:33:46 -0800137class ScreenCapturer;
chaviw60c9d3e2021-06-04 12:52:17 -0500138class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800139
Huihong Luo817ebb82023-12-13 12:54:24 -0800140using ::aidl::android::hardware::drm::HdcpLevels;
Huihong Luo791bef92023-09-19 21:18:45 -0700141using ::aidl::android::hardware::graphics::common::DisplayHotplugEvent;
ramindani12bfe6b2023-02-03 13:29:19 -0800142using ::aidl::android::hardware::graphics::composer3::RefreshRateChangedDebugData;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000143using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800144using gui::CaptureArgs;
145using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800146using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800147using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800148using gui::ScreenCaptureResults;
149
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700150namespace frametimeline {
151class FrameTimeline;
152}
153
Chris Ye0783e992020-06-02 21:34:49 -0700154namespace os {
155 class IInputFlinger;
156}
157
Lloyd Pique542307f2018-10-19 13:24:08 -0700158namespace compositionengine {
159class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800160class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800161
162struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700163} // namespace compositionengine
164
Peiyong Lin833074a2018-08-28 11:53:54 -0700165namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800166class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700167} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700168
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800169enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700170 eTransactionNeeded = 0x01,
171 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700172 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700173 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700174 eTransactionFlushNeeded = 0x10,
Patrick Williamsaf06b792023-02-16 17:46:22 -0600175 eInputInfoUpdateNeeded = 0x20,
176 eTransactionMask = 0x3f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800177};
178
Ady Abraham9dada822022-02-03 10:26:59 -0800179// Latch Unsignaled buffer behaviours
180enum class LatchUnsignaledConfig {
181 // All buffers are latched signaled.
182 Disabled,
183
184 // Latch unsignaled is permitted when a single layer is updated in a frame,
185 // and the update includes just a buffer update (i.e. no sync transactions
186 // or geometry changes).
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000187 // Latch unsignaled is also only permitted when a single transaction is ready
188 // to be applied. If we pass an unsignaled fence to HWC, HWC might miss presenting
189 // the frame if the fence does not fire in time. If we apply another transaction,
190 // we may penalize the other transaction unfairly.
Ady Abraham9dada822022-02-03 10:26:59 -0800191 AutoSingleLayer,
192
193 // All buffers are latched unsignaled. This behaviour is discouraged as it
194 // can break sync transactions, stall the display and cause undesired side effects.
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000195 // This is equivalent to ignoring the acquire fence when applying transactions.
Ady Abraham9dada822022-02-03 10:26:59 -0800196 Always,
197};
ramindani4d48f902021-09-20 21:07:45 +0000198
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000199struct DisplayRenderAreaBuilder;
200struct LayerRenderAreaBuilder;
201
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800202using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800203
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700204class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700205 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700206 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800207 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700208 private ICompositor,
jimmyshiu4e211772023-06-15 15:18:38 +0000209 private scheduler::ISchedulerCallback,
ramindaniae645822024-01-11 10:57:29 -0800210 private compositionengine::ICEPowerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800211public:
Lloyd Pique30db6402023-06-26 18:56:51 +0000212 struct SkipInitializationTag {};
213
214 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
215 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700216
217 // set main thread scheduling policy
218 static status_t setSchedFifo(bool enabled) ANDROID_API;
219
Wei Wang23aa5a62021-06-04 15:56:57 -0700220 // set main thread scheduling attributes
221 static status_t setSchedAttr(bool enabled);
222
Peiyong Linf243e5e2020-08-22 17:40:59 -0700223 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800224
Lloyd Pique30db6402023-06-26 18:56:51 +0000225 // If fences from sync Framework are supported.
226 static bool hasSyncFramework;
227
228 // The offset in nanoseconds to use when VsyncController timestamps present fence
229 // signaling time.
230 static int64_t dispSyncPresentTimeOffset;
231
232 // Some hardware can do RGB->YUV conversion more efficiently in hardware
233 // controlled by HWC than in hardware controlled by the video encoder.
234 // This instruct VirtualDisplaySurface to use HWC for such conversion on
235 // GL composition.
236 static bool useHwcForRgbToYuv;
237
238 // Controls the number of buffers SurfaceFlinger will allocate for use in
239 // FramebufferSurface
240 static int64_t maxFrameBufferAcquiredBuffers;
241
242 // Controls the minimum acquired buffers SurfaceFlinger will suggest via
243 // ISurfaceComposer.getMaxAcquiredBufferCount().
244 static int64_t minAcquiredBuffers;
245
246 // Controls the maximum width and height in pixels that the graphics pipeline can support for
247 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
248 static uint32_t maxGraphicsWidth;
249 static uint32_t maxGraphicsHeight;
250
Lloyd Pique30db6402023-06-26 18:56:51 +0000251 static bool useContextPriority;
252
253 // The data space and pixel format that SurfaceFlinger expects hardware composer
254 // to composite efficiently. Meaning under most scenarios, hardware composer
255 // will accept layers with the data space and pixel format.
256 static ui::Dataspace defaultCompositionDataspace;
257 static ui::PixelFormat defaultCompositionPixelFormat;
258
259 // The data space and pixel format that SurfaceFlinger expects hardware composer
260 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
261 // hardware composer will accept layers with the data space and pixel format.
262 static ui::Dataspace wideColorGamutCompositionDataspace;
263 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
264
265 static constexpr SkipInitializationTag SkipInitialization;
266
ramindani4d48f902021-09-20 21:07:45 +0000267 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700268
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700269 // must be called before clients can connect
270 void init() ANDROID_API;
271
272 // starts SurfaceFlinger main loop in the current thread
273 void run() ANDROID_API;
274
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700275 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
276 enum class FrameHint { kNone, kActive };
277
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700278 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Ady Abraham9953e062024-07-24 22:56:22 -0700279 void scheduleCommit(FrameHint, Duration workDurationSlack = Duration::fromNs(0));
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700280 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700281 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700282 // As above, but also force dirty geometry to repaint.
283 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700284 // Schedule sampling independently from commit or composite.
285 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800286
Lloyd Pique30db6402023-06-26 18:56:51 +0000287 surfaceflinger::Factory& getFactory() { return mFactory; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700288
Lloyd Pique70d91362018-10-18 16:02:55 -0700289 // The CompositionEngine encapsulates all composition related interfaces and actions.
290 compositionengine::CompositionEngine& getCompositionEngine() const;
291
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700292 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700293
Dominik Laskowski75848362019-11-11 17:57:20 -0800294 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700295 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700296 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700297
Vishnu Nair07e2a482022-10-18 19:18:16 +0000298 // Called when all clients have released all their references to
299 // this layer. The layer may still be kept alive by its parents but
300 // the client can no longer modify this layer directly.
Melody Hsucd391bc2024-09-24 23:46:53 +0000301 void onHandleDestroyed(sp<Layer>& layer, uint32_t layerId);
Vishnu Nair07e2a482022-10-18 19:18:16 +0000302
Robert Carr9a803c32021-01-14 16:57:58 -0800303 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
304 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700305 }
306
Lloyd Pique30db6402023-06-26 18:56:51 +0000307 // If set, disables reusing client composition buffers. This can be set by
308 // debug.sf.disable_client_composition_cache
309 bool mDisableClientCompositionCache = false;
310
Alec Mouridea1ac52021-06-23 18:12:18 -0700311 // Disables expensive rendering for all displays
312 // This is scheduled on the main thread
313 void disableExpensiveRendering();
314
Vishnu Naira3140382022-02-24 14:07:11 -0800315 // If set, composition engine tries to predict the composition strategy provided by HWC
316 // based on the previous frame. If the strategy can be predicted, gpu composition will
317 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
318 bool mPredictCompositionStrategy = false;
319
Lloyd Pique30db6402023-06-26 18:56:51 +0000320 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
321 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
322 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
323 // on this behavior to increase contrast for some media sources.
324 bool mTreat170mAsSrgb = false;
325
Alec Mouri9af38ba2023-08-16 22:41:14 +0000326 // If true, then screenshots with an enhanced render intent will dim in gamma space.
327 // The purpose is to ensure that screenshots appear correct during system animations for devices
328 // that require that dimming must occur in gamma space.
329 bool mDimInGammaSpaceForEnhancedScreenshots = false;
330
Lloyd Pique30db6402023-06-26 18:56:51 +0000331 // Allows to ignore physical orientation provided through hwc API in favour of
332 // 'ro.surface_flinger.primary_display_orientation'.
333 // TODO(b/246793311): Clean up a temporary property
334 bool mIgnoreHwcPhysicalDisplayOrientation = false;
335
Chavi Weingarten076acac2023-01-19 17:20:43 +0000336 void forceFutureUpdate(int delayInMs);
Vishnu Nair2f65e972023-04-04 16:36:28 +0000337 const DisplayDevice* getDisplayFromLayerStack(ui::LayerStack)
338 REQUIRES(mStateLock, kMainThreadContext);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000339
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400340 // TODO (b/259407931): Remove.
341 // TODO (b/281857977): This should be annotated with REQUIRES(kMainThreadContext), but this
342 // would require thread safety annotations throughout the frontend (in particular Layer and
343 // LayerFE).
344 static ui::Transform::RotationFlags getActiveDisplayRotationFlags() {
345 return sActiveDisplayRotationFlags;
346 }
347
Peiyong Linf243e5e2020-08-22 17:40:59 -0700348protected:
349 // We're reference counted, never destroy SurfaceFlinger directly
350 virtual ~SurfaceFlinger();
351
Dominik Laskowski263eec42021-07-21 23:13:24 -0700352 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
353 REQUIRES(mStateLock);
354
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800355 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000356 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800357
Dominik Laskowski263eec42021-07-21 23:13:24 -0700358 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
359 template <typename Predicate>
360 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
361 return static_cast<bool>(findDisplay(p));
362 }
363
chaviwba4320c2021-09-15 15:20:53 -0500364 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
365 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
366 }
367
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700368private:
David Sodman0c69cad2017-08-21 12:12:51 -0700369 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700370 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800371 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200372 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700373 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700374 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800375 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800376 friend class LayerRenderArea;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700377 friend class SurfaceComposerAIDL;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000378 friend class DisplayRenderArea;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800379
Lloyd Piquef58625d2017-12-19 13:22:33 -0800380 // For unit tests
381 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700382 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700383 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800384
Peiyong Linf243e5e2020-08-22 17:40:59 -0700385 using TransactionSchedule = scheduler::TransactionSchedule;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000386 using GetLayerSnapshotsFunction = std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>;
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000387 using RenderAreaBuilderVariant = std::variant<DisplayRenderAreaBuilder, LayerRenderAreaBuilder>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700388 using DumpArgs = Vector<String16>;
389 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
390
Robert Carr2047fae2016-11-28 14:09:09 -0800391 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800392 public:
Vishnu Naira12c5c72024-08-28 15:42:17 -0700393 explicit State(LayerVector::StateSet set) : stateSet(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700394 State& operator=(const State& other) {
395 // We explicitly don't copy stateSet so that, e.g., mDrawingState
396 // always uses the Drawing StateSet.
Dan Stoza412903f2017-04-27 13:42:17 -0700397 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700398 colorMatrixChanged = other.colorMatrixChanged;
399 if (colorMatrixChanged) {
400 colorMatrix = other.colorMatrix;
401 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800402 globalShadowSettings = other.globalShadowSettings;
403
Dan Stoza412903f2017-04-27 13:42:17 -0700404 return *this;
405 }
406
407 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Dominik Laskowski68399272022-09-15 07:54:46 -0700408
409 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
410 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
411
412 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
413 for (size_t i = 0; i < displays.size(); i++) {
414 const auto& state = displays.valueAt(i);
415 if (state.physical && state.physical->id == displayId) {
416 return i;
417 }
418 }
419
420 return {};
421 }
Robert Carr2047fae2016-11-28 14:09:09 -0800422
Chia-I Wu28f320b2018-05-03 11:02:56 -0700423 bool colorMatrixChanged = true;
424 mat4 colorMatrix;
425
Vishnu Naird9e4f462023-10-06 04:05:45 +0000426 ShadowSettings globalShadowSettings;
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:
Melody Hsucd391bc2024-09-24 23:46:53 +0000438 void increment(uint32_t layerId) {
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800439 std::lock_guard<std::mutex> lock(mLock);
Melody Hsucd391bc2024-09-24 23:46:53 +0000440 auto it = mCounterByLayerId.find(layerId);
441 if (it != mCounterByLayerId.end()) {
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800442 auto [name, pendingBuffers] = it->second;
443 int32_t count = ++(*pendingBuffers);
Vishnu Nairbe0ad902024-06-27 23:38:43 +0000444 SFTRACE_INT(name.c_str(), count);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800445 } else {
Melody Hsucd391bc2024-09-24 23:46:53 +0000446 ALOGW("Layer ID not found! %d", layerId);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800447 }
448 }
449
Melody Hsucd391bc2024-09-24 23:46:53 +0000450 void add(uint32_t layerId, const std::string& name, std::atomic<int32_t>* counter) {
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800451 std::lock_guard<std::mutex> lock(mLock);
Melody Hsucd391bc2024-09-24 23:46:53 +0000452 mCounterByLayerId[layerId] = std::make_pair(name, counter);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800453 }
454
Melody Hsucd391bc2024-09-24 23:46:53 +0000455 void remove(uint32_t layerId) {
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800456 std::lock_guard<std::mutex> lock(mLock);
Melody Hsucd391bc2024-09-24 23:46:53 +0000457 mCounterByLayerId.erase(layerId);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800458 }
459
460 private:
461 std::mutex mLock;
Melody Hsucd391bc2024-09-24 23:46:53 +0000462 std::unordered_map<uint32_t, std::pair<std::string, std::atomic<int32_t>*>>
463 mCounterByLayerId GUARDED_BY(mLock);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800464 };
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
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800478 Dumper lockedDumper(Dumper dump) {
479 return [this, dump](const DumpArgs& args, bool asProto, std::string& result) -> void {
480 TimedLock lock(mStateLock, s2ns(1), __func__);
481 if (!lock.locked()) {
482 base::StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
483 strerror(-lock.status), lock.status);
484 }
485 dump(args, asProto, result);
486 };
487 }
488
Peiyong Linf243e5e2020-08-22 17:40:59 -0700489 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
490 Dumper dumper(F dump) {
491 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800492 return lockedDumper(std::bind(dump, this, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700493 }
494
495 template <typename F>
496 Dumper argsDumper(F dump) {
497 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800498 return lockedDumper(std::bind(dump, this, _1, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700499 }
500
501 template <typename F>
502 Dumper protoDumper(F dump) {
503 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800504 return lockedDumper(std::bind(dump, this, _1, _2, _3));
505 }
506
Vishnu Naird1a05782024-03-19 04:37:38 +0000507 Dumper mainThreadDumperImpl(Dumper dumper) {
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800508 return [this, dumper](const DumpArgs& args, bool asProto, std::string& result) -> void {
509 mScheduler
510 ->schedule(
511 [&args, asProto, &result, dumper]() FTL_FAKE_GUARD(kMainThreadContext)
512 FTL_FAKE_GUARD(mStateLock) { dumper(args, asProto, result); })
513 .get();
514 };
Peiyong Linf243e5e2020-08-22 17:40:59 -0700515 }
516
Vishnu Naird1a05782024-03-19 04:37:38 +0000517 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
518 Dumper mainThreadDumper(F dump) {
519 using namespace std::placeholders;
520 return mainThreadDumperImpl(std::bind(dump, this, _3));
521 }
522
523 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
524 Dumper argsMainThreadDumper(F dump) {
525 using namespace std::placeholders;
526 return mainThreadDumperImpl(std::bind(dump, this, _1, _3));
527 }
528
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700529 // Maximum allowed number of display frames that can be set through backdoor
530 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700531
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700532 static const size_t MAX_LAYERS = 4096;
533
Alan Dingfc6eab52024-05-02 18:28:45 -0700534 static bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
Steven Thomasd4071902020-03-24 16:02:53 -0700535 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800536
Alan Dingfc6eab52024-05-02 18:28:45 -0700537 // IBinder overrides:
538 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
539 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
540
541 // ISurfaceComposer implementation:
Alan Dingd53801c2024-05-08 16:45:29 -0700542 sp<IBinder> createVirtualDisplay(const std::string& displayName, bool isSecure,
543 const std::string& uniqueId,
544 float requestedRefreshRate = 0.0f);
545 status_t destroyVirtualDisplay(const sp<IBinder>& displayToken);
Huihong Luo07e72362022-02-14 14:26:04 -0800546 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700547 Mutex::Autolock lock(mStateLock);
548 return getPhysicalDisplayIdsLocked();
549 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700550
Huihong Luo07e72362022-02-14 14:26:04 -0800551 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Pablo Gamito23780be2023-04-18 08:30:00 +0000552 status_t setTransactionState(
553 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& state,
Patrick Williamsf65da8a2024-07-24 17:11:19 +0000554 Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
Pablo Gamito23780be2023-04-18 08:30:00 +0000555 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime,
556 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
557 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
558 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700559 void bootFinished();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -0500560 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800561 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700562 gui::ISurfaceComposer::VsyncSource vsyncSource =
563 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
Rachel Lee2248f522023-01-27 16:45:23 -0800564 EventRegistrationFlags eventRegistration = {},
565 const sp<IBinder>& layerHandle = nullptr);
Dominik Laskowskif1833852021-03-23 15:06:50 -0700566
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000567 void captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
John Reck7e4c4872023-11-14 18:31:03 -0500568 void captureDisplay(DisplayId, const CaptureArgs&, const sp<IScreenCaptureListener>&);
Chavi Weingartenf6fb4452024-01-23 21:10:30 +0000569 ScreenCaptureResults captureLayersSync(const LayerCaptureArgs&);
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000570 void captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700571
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800572 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100573 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800574 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700575 status_t getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo*) EXCLUDES(mStateLock);
576 status_t getDynamicDisplayInfoFromId(int64_t displayId, ui::DynamicDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800577 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700578 status_t getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
579 ui::DynamicDisplayInfo*) EXCLUDES(mStateLock);
580 void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*&, const sp<DisplayDevice>&,
581 const display::DisplaySnapshot&);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800582 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
583 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800584 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700585 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700586 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800587 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
Kriti Dang674b9372022-11-18 10:58:44 +0100588 status_t getHdrConversionCapabilities(
589 std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const;
Kriti Dangd432bb52023-02-09 18:21:04 +0100590 status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
591 int32_t*);
Kriti Dang674b9372022-11-18 10:58:44 +0100592 status_t getHdrOutputConversionSupport(bool* outSupport) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800593 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
594 void setGameContentType(const sp<IBinder>& displayToken, bool on);
595 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100596 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800597 const std::vector<ui::Hdr>& hdrTypes);
Huihong Luo30aa4372022-10-03 14:54:12 -0700598 status_t onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData, bool* success);
Peiyong Linc6780972018-10-28 15:24:08 -0700599 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
600 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800601 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700602 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800603 ui::PixelFormat* outFormat,
604 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800605 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700606 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800607 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700608 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800609 uint64_t timestamp, DisplayedFrameStats* outStats) const;
610 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800611 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800612 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800613 const sp<IRegionSamplingListener>& listener);
614 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
615 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
616 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
617 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
618 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100619 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700620 const gui::DisplayModeSpecs&);
621 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800622 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500623 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800624 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400625 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800626 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400627 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800628 const sp<gui::IHdrLayerInfoListener>& listener);
629 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800630 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800631 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500632 status_t getDisplayDecorationSupport(
633 const sp<IBinder>& displayToken,
634 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800635 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800636 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800637 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700638
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000639 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800640 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700641
Andy Yu8c2703d2023-11-03 11:22:46 -0700642 status_t setGameModeFrameRateOverride(uid_t uid, float frameRate);
643
644 status_t setGameDefaultFrameRateOverride(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800645
Tony Huangf3621102023-09-04 17:14:22 +0800646 status_t updateSmallAreaDetection(std::vector<std::pair<int32_t, float>>& uidThresholdMappings);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000647
Tony Huangf3621102023-09-04 17:14:22 +0800648 status_t setSmallAreaDetectionThreshold(int32_t appId, float threshold);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000649
Huihong Luo02186fb2022-02-23 14:21:54 -0800650 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800651
Huihong Luo02186fb2022-02-23 14:21:54 -0800652 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800653
Patrick Williamsacd22582023-07-12 13:47:28 -0500654 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
655 gui::WindowInfosListenerInfo* outResult);
chaviw60c9d3e2021-06-04 12:52:17 -0500656 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800657 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500658
Patrick Williams090ad062023-08-08 12:30:10 -0500659 status_t getStalledTransactionInfo(
660 int pid, std::optional<TransactionHandler::StalledTransactionInfo>& result);
661
Huihong Luo9ebb7a72023-06-27 17:01:50 -0700662 void updateHdcpLevels(hal::HWDisplayId hwcDisplayId, int32_t connectedLevel, int32_t maxLevel);
663
Alan Dingfc6eab52024-05-02 18:28:45 -0700664 // IBinder::DeathRecipient overrides:
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800665 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800666
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700667 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400668 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700669 std::optional<hal::VsyncPeriodNanos>) override;
Huihong Luo791bef92023-09-19 21:18:45 -0700670 void onComposerHalHotplugEvent(hal::HWDisplayId, DisplayHotplugEvent) override;
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700671 void onComposerHalRefresh(hal::HWDisplayId) override;
672 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
673 const hal::VsyncPeriodChangeTimeline&) override;
674 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800675 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
ramindani12bfe6b2023-02-03 13:29:19 -0800676 void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) override;
Huihong Luo817ebb82023-12-13 12:54:24 -0800677 void onComposerHalHdcpLevelsChanged(hal::HWDisplayId, const HdcpLevels& levels) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700678
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700679 // ICompositor overrides:
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500680 void configure() override REQUIRES(kMainThreadContext);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400681 bool commit(PhysicalDisplayId pacesetterId, const scheduler::FrameTargets&) override
682 REQUIRES(kMainThreadContext);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500683 CompositeResultsPerDisplay composite(PhysicalDisplayId pacesetterId,
684 const scheduler::FrameTargeters&) override
685 REQUIRES(kMainThreadContext);
686
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700687 void sample() override;
688
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700689 // ISchedulerCallback overrides:
Dominik Laskowski66295432023-03-14 12:25:36 -0400690 void requestHardwareVsync(PhysicalDisplayId, bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400691 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800692 void kernelTimerChanged(bool expired) override;
Ady Abraham822ecbd2023-07-07 16:16:09 -0700693 void onChoreographerAttached() override;
ramindaniae645822024-01-11 10:57:29 -0800694 void onExpectedPresentTimePosted(TimePoint expectedPresentTime, ftl::NonNull<DisplayModePtr>,
695 Fps renderRate) override;
Ady Abraham14beed72024-05-15 17:16:45 -0700696 void onCommitNotComposited(PhysicalDisplayId pacesetterDisplayId) override
697 REQUIRES(kMainThreadContext);
Ady Abrahameba039c2024-07-10 17:45:29 -0700698 void vrrDisplayIdle(bool idle) override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700699
jimmyshiu4e211772023-06-15 15:18:38 +0000700 // ICEPowerCallback overrides:
701 void notifyCpuLoadUp() override;
702
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400703 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400704
ramindani32cf0602022-03-02 02:30:29 +0000705 // Get the controller and timeout that will help decide how the kernel idle timer will be
706 // configured and what value to use as the timeout.
707 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
Dominik Laskowski6e465152022-09-28 11:00:25 -0400708 getKernelIdleTimerProperties(PhysicalDisplayId) REQUIRES(mStateLock);
Dominik Laskowski43839672024-08-04 02:01:48 -0400709
Lloyd Pique30db6402023-06-26 18:56:51 +0000710 // Show spinner with refresh rate overlay
711 bool mRefreshRateOverlaySpinner = false;
712 // Show render rate with refresh rate overlay
713 bool mRefreshRateOverlayRenderRate = false;
714 // Show render rate overlay offseted to the middle of the screen (e.g. for circular displays)
715 bool mRefreshRateOverlayShowInMiddle = false;
Sally Qi147581b2023-06-27 11:55:34 -0700716 // Show hdr sdr ratio overlay
717 bool mHdrSdrRatioOverlay = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700718
Bart Sears2d7e7f82024-07-13 19:42:29 +0000719 void setDesiredMode(display::DisplayModeRequest&&) REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400720
Ady Abraham38027262023-10-17 16:58:25 -0700721 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId, Fps minFps,
722 Fps maxFps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400723
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400724 void initiateDisplayModeChanges() REQUIRES(kMainThreadContext) REQUIRES(mStateLock);
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400725 void finalizeDisplayModeChange(PhysicalDisplayId) REQUIRES(kMainThreadContext)
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400726 REQUIRES(mStateLock);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400727
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400728 void dropModeRequest(PhysicalDisplayId) REQUIRES(kMainThreadContext);
729 void applyActiveMode(PhysicalDisplayId) REQUIRES(kMainThreadContext);
Dominik Laskowski59746512023-11-19 09:30:24 -0500730
Marin Shalamanov5801c942020-12-17 17:00:13 +0100731 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700732 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700733 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800734
Dominik Laskowskif2595442022-08-29 13:51:57 -0700735 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
736 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800737 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400738 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700739
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400740 status_t setDesiredDisplayModeSpecsInternal(
741 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700742 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800743
Dominik Laskowski3f726402022-11-21 17:21:22 -0500744 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
745 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
Dominik Laskowski1746afd2024-04-10 19:21:37 -0400746 const scheduler::RefreshRateSelector&)
Dominik Laskowski3f726402022-11-21 17:21:22 -0500747 REQUIRES(mStateLock, kMainThreadContext);
748
Vishnu Nair878911f2024-03-27 22:20:24 -0700749 void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700750 void commitTransactionsLocked(uint32_t transactionFlags)
751 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700752 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800753
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000754 std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(
Vishnu Nair7be27602024-03-28 20:27:09 -0700755 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
756 REQUIRES(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000757 void moveSnapshotsFromCompositionArgs(compositionengine::CompositionRefreshArgs& refreshArgs,
Vishnu Nair7be27602024-03-28 20:27:09 -0700758 const std::vector<std::pair<Layer*, LayerFE*>>& layers)
759 REQUIRES(kMainThreadContext);
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700760 // Return true if we must composite this frame
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000761 bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000762 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nair7be27602024-03-28 20:27:09 -0700763 void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800764
Vishnu Nair7be27602024-03-28 20:27:09 -0700765 void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800766 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800767 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
Vishnu Nair7be27602024-03-28 20:27:09 -0700768 std::vector<gui::DisplayInfo>& outDisplayInfos)
769 REQUIRES(kMainThreadContext);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800770 void commitInputWindowCommands() REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -0700771 void updateCursorAsync() REQUIRES(kMainThreadContext);
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700772
Dominik Laskowski59db9562022-10-27 16:18:53 -0400773 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowski14956dc2023-02-22 13:43:57 -0500774
Peiyong Linf243e5e2020-08-22 17:40:59 -0700775 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700776 * Transactions
777 */
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000778 bool applyTransactionState(const FrameTimelineInfo& info,
779 std::vector<ResolvedComposerState>& state,
780 Vector<DisplayState>& displays, uint32_t flags,
781 const InputWindowCommands& inputWindowCommands,
782 const int64_t desiredPresentTime, bool isAutoTimestamp,
783 const std::vector<uint64_t>& uncacheBufferIds,
784 const int64_t postTime, bool hasListenerCallbacks,
785 const std::vector<ListenerCallbacks>& listenerCallbacks,
786 int originPid, int originUid, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700787 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700788 // Flush pending transactions that were presented after desiredPresentTime.
Vishnu Nair42ad3192023-01-24 19:17:59 -0800789 // For test only
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000790 bool flushTransactionQueues() REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800791
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000792 bool applyTransactions(std::vector<TransactionState>&) REQUIRES(kMainThreadContext);
Vishnu Nair878911f2024-03-27 22:20:24 -0700793 bool applyAndCommitDisplayTransactionStatesLocked(std::vector<TransactionState>& transactions)
794 REQUIRES(kMainThreadContext, mStateLock);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800795
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700796 // Returns true if there is at least one transaction that needs to be flushed
Vishnu Nair7be27602024-03-28 20:27:09 -0700797 bool transactionFlushNeeded() REQUIRES(kMainThreadContext);
798 void addTransactionReadyFilters() REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700799 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
800 const TransactionHandler::TransactionFlushState& flushState)
801 REQUIRES(kMainThreadContext);
802 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
803 const TransactionHandler::TransactionFlushState& flushState)
804 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800805
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000806 uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,
807 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000808 int64_t postTime, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700809 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700810 uint32_t getTransactionFlags() const;
811
Dominik Laskowski94000c42022-03-17 12:55:14 -0700812 // Sets the masked bits, and schedules a commit if needed.
813 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700814 const sp<IBinder>& applyToken = nullptr,
815 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700816
817 // Clears and returns the masked bits.
818 uint32_t clearTransactionFlags(uint32_t mask);
819
ramindani4d48f902021-09-20 21:07:45 +0000820 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000821 bool shouldLatchUnsignaled(const layer_state_t&, size_t numStates, bool firstTransaction) const;
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000822 bool applyTransactionsLocked(std::vector<TransactionState>& transactions)
Vishnu Nair7be27602024-03-28 20:27:09 -0700823 REQUIRES(mStateLock, kMainThreadContext);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800824 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800825 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
826 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700827 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
828
Peiyong Linf243e5e2020-08-22 17:40:59 -0700829 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700830 * Layer management
831 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000832 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800833
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800834 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
835 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700836
Vishnu Nair84125ac2021-12-02 08:47:48 -0800837 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800838 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700839
Vishnu Nair84125ac2021-12-02 08:47:48 -0800840 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000841 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700842
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000843 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000844 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000845
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700846 // add a layer to SurfaceFlinger
Vishnu Nair1391de22023-03-05 19:56:14 -0800847 status_t addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Naircb8be502022-10-12 19:03:23 +0000848 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700849 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700850
Melody Hsu793f8362024-01-08 20:00:35 +0000851 // Creates a promise for a future release fence for a layer. This allows for
852 // the layer to keep track of when its buffer can be released.
853 void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
854
855 // Checks if a protected layer exists in a list of layers.
Melody Hsu0b80c742024-10-29 07:24:29 +0000856 bool layersHasProtectedLayer(const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const;
Melody Hsu8c42cf12024-06-05 00:07:03 +0000857
858 using OutputCompositionState = compositionengine::impl::OutputCompositionState;
859
Vishnu Nair5a93ccb2024-06-26 00:38:32 +0000860 std::optional<OutputCompositionState> getSnapshotsFromMainThread(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000861 RenderAreaBuilderVariant& renderAreaBuilder,
Melody Hsu0b80c742024-10-29 07:24:29 +0000862 GetLayerSnapshotsFunction getLayerSnapshotsFn,
863 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers);
Melody Hsu82d524e2024-02-23 02:37:38 +0000864
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000865 void captureScreenCommon(RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
866 ui::Size bufferSize, ui::PixelFormat, bool allowProtected,
Alec Mouri1b1853f2024-07-15 22:46:58 +0000867 bool grayscale, bool attachGainmap, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000868
Melody Hsu8c42cf12024-06-05 00:07:03 +0000869 std::optional<OutputCompositionState> getDisplayStateFromRenderAreaBuilder(
870 RenderAreaBuilderVariant& renderAreaBuilder) REQUIRES(kMainThreadContext);
Melody Hsu335ef3e2024-05-31 22:58:40 +0000871
Melody Hsu82d524e2024-02-23 02:37:38 +0000872 ftl::SharedFuture<FenceResult> captureScreenshot(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000873 const RenderAreaBuilderVariant& renderAreaBuilder,
874 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
Alec Mouri1b1853f2024-07-15 22:46:58 +0000875 bool grayscale, bool isProtected, bool attachGainmap,
876 const sp<IScreenCaptureListener>& captureListener,
Melody Hsu8c42cf12024-06-05 00:07:03 +0000877 std::optional<OutputCompositionState>& displayState,
Melody Hsu0b80c742024-10-29 07:24:29 +0000878 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers);
Melody Hsu8c42cf12024-06-05 00:07:03 +0000879
Melody Hsu793f8362024-01-08 20:00:35 +0000880 ftl::SharedFuture<FenceResult> renderScreenImpl(
Alec Mouri1b1853f2024-07-15 22:46:58 +0000881 const RenderArea*, const std::shared_ptr<renderengine::ExternalTexture>&,
Melody Hsu16c4c322024-10-29 07:50:14 +0000882 bool regionSampling, bool grayscale, bool isProtected, ScreenCaptureResults&,
883 std::optional<OutputCompositionState>& displayState,
Melody Hsu0b80c742024-10-29 07:24:29 +0000884 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers);
Melody Hsu793f8362024-01-08 20:00:35 +0000885
Romain Guy11d63f42017-07-20 12:47:14 -0700886 void readPersistentProperties();
887
rnleeed20fa42021-08-10 18:00:03 -0700888 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700889
Peiyong Linf243e5e2020-08-22 17:40:59 -0700890 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700891 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700892 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700893
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400894 // Called during boot and restart after system_server death, setting the stage for bootanimation
895 // before DisplayManager takes over.
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400896 void initializeDisplays() REQUIRES(kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700897
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700898 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
899 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700900 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700901 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700902
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700903 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski80872bd2022-11-15 11:34:33 -0500904 return mDisplays.get(displayToken)
905 .or_else(ftl::static_ref<sp<DisplayDevice>>([] { return nullptr; }))
906 .value();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700907 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700908
Ady Abraham690f4612021-07-01 23:24:03 -0700909 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
910 REQUIRES(mStateLock) {
911 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
912 }
913
914 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
915 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
916 return getDisplayDeviceLocked(token);
917 }
918 return nullptr;
919 }
920
Dominik Laskowski3c363242022-04-07 10:44:12 -0700921 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
922 // TODO(b/182939859): Replace tokens with IDs for display lookup.
923 return findDisplay([id](const auto& display) { return display.getId() == id; });
924 }
925
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500926 std::shared_ptr<compositionengine::Display> getCompositionDisplayLocked(DisplayId id) const
927 REQUIRES(mStateLock) {
928 if (const auto display = getDisplayDeviceLocked(id)) {
929 return display->getCompositionDisplay();
930 }
931 return nullptr;
932 }
933
Dominik Laskowskia0858db2024-07-23 16:45:11 -0400934 // Returns the primary display or (for foldables) the active display.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700935 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700936 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700937 }
938
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700939 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -0700940 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -0700941 }
942
Ady Abraham3efa3942021-06-24 19:01:25 -0700943 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700944 Mutex::Autolock lock(mStateLock);
945 return getDefaultDisplayDeviceLocked();
946 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200947
Dominik Laskowski6e465152022-09-28 11:00:25 -0400948 using DisplayDeviceAndSnapshot = std::pair<sp<DisplayDevice>, display::DisplaySnapshotRef>;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700949
950 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
951 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
952 return [this](const display::PhysicalDisplay& display) REQUIRES(
953 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
954 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
955 return std::make_pair(std::move(device), display.snapshotRef());
956 }
957
958 return {};
959 };
960 }
961
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700962 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
963 template <typename Predicate>
964 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
965 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
Dominik Laskowski3de67272023-08-09 13:15:31 -0400966 [&](const auto& pair)
967 REQUIRES(mStateLock) { return p(*pair.second); });
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700968
969 return it == mDisplays.end() ? nullptr : it->second;
970 }
971
Ady Abrahamed3290f2021-05-17 15:12:14 -0700972 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
973
Mathias Agopian87baae12012-07-31 12:38:26 -0700974 // mark a region of a layer stack dirty. this updates the dirty
975 // region of all screens presenting this layer stack.
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000976 void invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700977
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700978 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
979 REQUIRES(mStateLock) {
980 return {layerStack,
981 PhysicalDisplayId::tryCast(displayId)
982 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
983 .transform(&display::PhysicalDisplay::isInternal)
984 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -0700985 }
986
Peiyong Linf243e5e2020-08-22 17:40:59 -0700987 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700988 * H/W composer
989 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100990 // The following thread safety rules apply when accessing HWComposer:
991 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
992 // acquire mStateLock.
993 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -0700994 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +0100995 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -0700996 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700997
Peiyong Linf243e5e2020-08-22 17:40:59 -0700998 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700999 * Compositing
1000 */
Leon Scroggins III5b581492023-10-31 14:29:41 -04001001 void onCompositionPresented(PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters&,
1002 nsecs_t presentStartTime) REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -07001003
Peiyong Linf243e5e2020-08-22 17:40:59 -07001004 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -07001005 * Display management
1006 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001007 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
1008 REQUIRES(mStateLock);
1009
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001010 // TODO(b/241285876): Move to DisplayConfigurator.
1011 //
1012 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
1013 // commit display transactions.
1014 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
1015 EXCLUDES(mHotplugMutex);
1016
Dominik Laskowski6e465152022-09-28 11:00:25 -04001017 // Returns the active mode ID, or nullopt on hotplug failure.
1018 std::optional<DisplayModeId> processHotplugConnect(PhysicalDisplayId, hal::HWDisplayId,
1019 DisplayIdentificationInfo&&,
1020 const char* displayString)
1021 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb8267b2024-04-26 16:23:07 -04001022 void processHotplugDisconnect(PhysicalDisplayId, const char* displayString)
1023 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07001024
Lloyd Pique542307f2018-10-19 13:24:08 -07001025 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07001026 const wp<IBinder>& displayToken,
1027 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -07001028 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +01001029 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001030 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001031 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001032 void processDisplayRemoved(const wp<IBinder>& displayToken)
1033 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +01001034 void processDisplayChanged(const wp<IBinder>& displayToken,
1035 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001036 const DisplayDeviceState& drawingState)
1037 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001038
Peiyong Linf243e5e2020-08-22 17:40:59 -07001039 /*
Dominik Laskowskic2867142019-01-21 11:33:38 -08001040 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001041 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001042 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +02001043 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001044 return mPhysicalDisplays.get(displayId)
1045 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
Dominik Laskowski80872bd2022-11-15 11:34:33 -05001046 .or_else([] { return std::optional<sp<display::DisplayToken>>(nullptr); })
1047 .value();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001048 }
1049
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001050 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001051 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001052
Dominik Laskowski3c363242022-04-07 10:44:12 -07001053 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001054 //
Dominik Laskowski3c363242022-04-07 10:44:12 -07001055 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
1056 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
1057 // display because SF does not support disconnecting it, though in practice HWC may circumvent
1058 // this limitation.)
1059 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
1060 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001061 }
1062
Dominik Laskowski3c363242022-04-07 10:44:12 -07001063 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001064 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001065 }
1066
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001067 // Toggles use of HAL/GPU virtual displays.
1068 void enableHalVirtualDisplays(bool);
1069
1070 // Virtual display lifecycle for ID generation and HAL allocation.
Gil Dekel5d660422024-10-25 16:20:13 -04001071 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat, const std::string& uniqueId)
1072 REQUIRES(mStateLock);
1073 template <typename ID>
1074 void acquireVirtualDisplaySnapshot(ID displayId, const std::string& uniqueId) {
1075 std::lock_guard lock(mVirtualDisplaysMutex);
1076 const bool emplace_success =
1077 mVirtualDisplays.try_emplace(displayId, displayId, uniqueId).second;
1078 if (!emplace_success) {
1079 ALOGW("%s: Virtual display snapshot with the same ID already exists", __func__);
1080 }
1081 }
1082
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001083 void releaseVirtualDisplay(VirtualDisplayId);
Gil Dekel5d660422024-10-25 16:20:13 -04001084 void releaseVirtualDisplaySnapshot(VirtualDisplayId displayId);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001085
Dominik Laskowski3de67272023-08-09 13:15:31 -04001086 // Returns a display other than `mActiveDisplayId` that can be activated, if any.
1087 sp<DisplayDevice> getActivatableDisplay() const REQUIRES(mStateLock, kMainThreadContext);
1088
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001089 void onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
1090 const DisplayDevice& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001091 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001092
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001093 void onActiveDisplaySizeChanged(const DisplayDevice&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001094
Dominik Laskowskic2867142019-01-21 11:33:38 -08001095 /*
1096 * Debugging & dumpsys
1097 */
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001098 void dumpAll(const DumpArgs& args, const std::string& compositionLayers,
1099 std::string& result) const EXCLUDES(mStateLock);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00001100 void dumpHwcLayersMinidump(std::string& result) const REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001101
1102 void appendSfConfigString(std::string& result) const;
Vishnu Nair7be27602024-03-28 20:27:09 -07001103 void listLayers(std::string& result) const REQUIRES(kMainThreadContext);
1104 void dumpStats(const DumpArgs& args, std::string& result) const
1105 REQUIRES(mStateLock, kMainThreadContext);
1106 void clearStats(const DumpArgs& args, std::string& result) REQUIRES(kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001107 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001108 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001109 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001110
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001111 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1112 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1113 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001114
1115 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1116 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001117 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001118 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001119 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
John Reck2a3d29d2023-08-17 17:45:01 -04001120 void dumpHdrInfo(std::string& result) const REQUIRES(mStateLock);
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001121 void dumpFrontEnd(std::string& result) REQUIRES(kMainThreadContext);
1122 void dumpVisibleFrontEnd(std::string& result) REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001123
Vishnu Nair7be27602024-03-28 20:27:09 -07001124 perfetto::protos::LayersProto dumpDrawingStateProto(uint32_t traceFlags) const
1125 REQUIRES(kMainThreadContext);
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001126 google::protobuf::RepeatedPtrField<perfetto::protos::DisplayProto> dumpDisplayProto() const;
Kean Mariotti639b54f2023-04-20 12:06:29 +00001127 void doActiveLayersTracingIfNeeded(bool isCompositionComputed, bool visibleRegionDirty,
1128 TimePoint, VsyncId) REQUIRES(kMainThreadContext);
1129 perfetto::protos::LayersSnapshotProto takeLayersSnapshotProto(uint32_t flags, TimePoint,
1130 VsyncId, bool visibleRegionDirty)
Vishnu Nair81750622023-03-08 15:02:06 -08001131 REQUIRES(kMainThreadContext);
chaviw0a398992021-08-13 10:13:01 -05001132
Alec Mouri6b9e9912020-01-21 10:50:24 -08001133 // Dumps state from HW Composer
1134 void dumpHwc(std::string& result) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001135 perfetto::protos::LayersProto dumpProtoFromMainThread(
1136 uint32_t traceFlags = LayerTracing::TRACE_ALL) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001137 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001138
Dominik Laskowskic2867142019-01-21 11:33:38 -08001139 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1140
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001141 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001142
1143 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1144 return doDump(fd, args, asProto);
1145 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001146
chaviw17ac24b2021-01-28 18:50:05 -08001147 static mat4 calculateColorMatrix(float saturation);
1148
Chia-I Wu28f320b2018-05-03 11:02:56 -07001149 void updateColorMatrixLocked();
1150
Peiyong Linf243e5e2020-08-22 17:40:59 -07001151 // Verify that transaction is being called by an approved process:
1152 // either AID_GRAPHICS or AID_SYSTEM.
1153 status_t CheckTransactCodeCredentials(uint32_t code);
1154
Ady Abrahame46243a2021-02-23 19:33:49 -08001155 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001156
Peiyong Linf243e5e2020-08-22 17:40:59 -07001157 /*
1158 * Generic Layer Metadata
1159 */
1160 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1161
Lloyd Pique30db6402023-06-26 18:56:51 +00001162 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1163 std::chrono::nanoseconds presentLatency);
Ady Abraham899dcdb2021-06-15 16:56:21 -07001164 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001165
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00001166 bool isHdrLayer(const frontend::LayerSnapshot& snapshot) const;
John Reck49d9ad32022-02-23 19:03:31 -05001167
ramindani06e518e2022-03-14 18:47:53 +00001168 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1169 REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001170 void traverseLegacyLayers(const LayerVector::Visitor& visitor) const
1171 REQUIRES(kMainThreadContext);
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001172
1173 void initBootProperties();
Vishnu Nair8c5b7002023-08-17 21:03:57 -07001174 void initTransactionTraceWriter();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001175
Lloyd Pique30db6402023-06-26 18:56:51 +00001176 surfaceflinger::Factory& mFactory;
1177 pid_t mPid;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001178
1179 // TODO: b/328459745 - Encapsulate in a SystemProperties object.
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001180 utils::OnceFuture mInitBootPropsFuture;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001181
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001182 utils::OnceFuture mRenderEnginePrimeCacheFuture;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001183
Leon Scroggins III67388622023-02-06 20:36:20 -05001184 // mStateLock has conventions related to the current thread, because only
1185 // the main thread should modify variables protected by mStateLock.
1186 // - read access from a non-main thread must lock mStateLock, since the main
1187 // thread may modify these variables.
1188 // - write access from a non-main thread is not permitted.
1189 // - read access from the main thread can use an ftl::FakeGuard, since other
1190 // threads must not modify these variables.
1191 // - write access from the main thread must lock mStateLock, since another
1192 // thread may be reading these variables.
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001193 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001194 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001195 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001196 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001197
Brian Lindahl439afad2022-11-14 11:16:55 -07001198 // Buffers that have been discarded by clients and need to be evicted from per-layer caches so
1199 // the graphics memory can be immediately freed.
1200 std::vector<uint64_t> mBufferIdsToUncache;
1201
Chia-I Wu28f320b2018-05-03 11:02:56 -07001202 // global color transform states
1203 Daltonizer mDaltonizer;
1204 float mGlobalSaturationFactor = 1.0f;
1205 mat4 mClientColorMatrix;
1206
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001207 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001208 bool mLayersRemoved = false;
1209 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001210
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001211 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001212 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001213
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001214 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001215 const nsecs_t mBootTime = systemTime();
Lloyd Pique30db6402023-06-26 18:56:51 +00001216 bool mIsUserBuild = true;
Dominik Laskowskie62606d2024-02-22 11:42:13 -05001217 bool mHasReliablePresentFences = false;
Mathias Agopian3094df32012-06-18 18:06:45 -07001218
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001219 // Can only accessed from the main thread, these members
1220 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001221 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001222 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001223
John Reck68796592023-01-25 13:47:12 -05001224 bool mHdrLayerInfoChanged = false;
1225
Alec Mourid05a7452024-09-20 13:44:02 +00001226 struct LayerEvent {
1227 uid_t uid;
1228 int32_t layerId;
1229 ui::Dataspace dataspace;
1230 std::chrono::milliseconds timeSinceLastEvent;
1231 };
1232 std::vector<LayerEvent> mLayerEvents;
1233
Robert Carr167bdde2021-07-28 11:26:51 -07001234 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1235 // scene hasn't changed
1236 bool mAddingHDRLayerInfoListener = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00001237 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001238
Robert Carre450fb52021-06-11 13:21:09 -07001239 // Set during transaction application stage to track if the input info or children
1240 // for a layer has changed.
1241 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001242 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001243 bool mSomeChildrenChanged;
Ady Abraham822ecbd2023-07-07 16:16:09 -07001244 bool mUpdateAttachedChoreographer = false;
Robert Carre450fb52021-06-11 13:21:09 -07001245
Vishnu Nair39a74a92024-07-29 19:01:50 +00001246 struct LayerIntHash {
1247 size_t operator()(const std::pair<sp<Layer>, gui::GameMode>& k) const {
1248 return std::hash<Layer*>()(k.first.get()) ^
1249 std::hash<int32_t>()(static_cast<int32_t>(k.second));
1250 }
1251 };
1252
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001253 // TODO(b/238781169) validate these on composition
Alec Mouri5c9c9602020-09-01 15:10:40 -07001254 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001255 // latched.
Vishnu Nair39a74a92024-07-29 19:01:50 +00001256 std::unordered_set<std::pair<sp<Layer>, gui::GameMode>, LayerIntHash> mLayersWithQueuedFrames;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001257 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;
Vishnu Nair6f209e22023-08-04 16:33:23 +00001258
Vishnu Nair802ac4f2023-05-10 13:55:22 -07001259 // Sorted list of layers that were composed during previous frame. This is used to
1260 // avoid an expensive traversal of the layer hierarchy when there are no
1261 // visible region changes. Because this is a list of strong pointers, this will
1262 // extend the life of the layer but this list is only updated in the main thread.
1263 std::vector<sp<Layer>> mPreviouslyComposedLayers;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001264
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001265 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001266
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001267 struct HotplugEvent {
1268 hal::HWDisplayId hwcDisplayId;
1269 hal::Connection connection = hal::Connection::INVALID;
1270 };
1271
Huihong Luo9ebb7a72023-06-27 17:01:50 -07001272 bool mIsHdcpViaNegVsync = false;
Huihong Luoaac3a772023-09-19 20:51:59 -07001273
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001274 std::mutex mHotplugMutex;
1275 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001276
Dominik Laskowskieb627312022-04-07 09:13:16 -07001277 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1278 // never removed, so take precedence over external and virtual displays.
1279 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001280 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001281 ui::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001282
1283 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001284
Gil Dekel5d660422024-10-25 16:20:13 -04001285 mutable std::mutex mVirtualDisplaysMutex;
1286 ftl::SmallMap<VirtualDisplayId, const display::VirtualDisplaySnapshot, 2> mVirtualDisplays
1287 GUARDED_BY(mVirtualDisplaysMutex);
1288
Dominik Laskowskia0858db2024-07-23 16:45:11 -04001289 // The inner or outer display for foldables, while unfolded or folded, respectively.
Dominik Laskowski5c989f52024-04-11 13:57:14 -04001290 std::atomic<PhysicalDisplayId> mActiveDisplayId;
Dominik Laskowskie591b552022-09-09 10:44:56 -07001291
Dominik Laskowski6e465152022-09-28 11:00:25 -04001292 display::DisplayModeController mDisplayModeController;
1293
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001294 struct {
1295 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1296 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1297 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001298
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001299 std::atomic_uint mDebugFlashDelay = 0;
1300 std::atomic_bool mDebugDisableHWC = false;
1301 std::atomic_bool mDebugDisableTransformHint = false;
1302 std::atomic<nsecs_t> mDebugInTransaction = 0;
1303 std::atomic_bool mForceFullDamage = false;
1304
Lloyd Pique30db6402023-06-26 18:56:51 +00001305 bool mLayerCachingEnabled = false;
1306 bool mBackpressureGpuComposition = false;
1307
Vishnu Nair81750622023-03-08 15:02:06 -08001308 LayerTracing mLayerTracing;
Dominik Laskowski46471e62022-01-14 15:34:03 -08001309 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001310
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001311 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001312 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001313 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001314
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001315 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001316
Lloyd Pique30db6402023-06-26 18:56:51 +00001317 // If blurs should be enabled on this device.
1318 bool mSupportsBlur = false;
1319
Robert Carr9a803c32021-01-14 16:57:58 -08001320 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001321
chaviweadf0d42019-08-12 13:28:29 -07001322 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001323
Steven Morelanda904bb92019-07-02 17:37:23 -07001324 // to linkToDeath
1325 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001326 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1327 // different threads without a lock and could trigger unsynchronized writes to
1328 // to mWindowManager or mInputFlinger
1329 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001330
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001331 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001332
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001333 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001334
Peiyong Lina3ea5592019-02-10 14:45:00 -08001335 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1336 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1337 // 2. be one of the supported color modes returned by hardware composer, otherwise
1338 // it will not be respected.
1339 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1340 // is not set to 1.
1341 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1342 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1343
Lloyd Pique30db6402023-06-26 18:56:51 +00001344 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1345 // If false, wide color modes are filtered out for all internal displays.
1346 bool mSupportsWideColor = false;
Dominik Laskowski788945b2022-08-30 12:10:56 -07001347
Lloyd Pique30db6402023-06-26 18:56:51 +00001348 ui::Dataspace mDefaultCompositionDataspace;
1349 ui::Dataspace mWideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001350
Patrick Williams0a525a42022-10-26 20:20:50 +00001351 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Chavi Weingarten076acac2023-01-19 17:20:43 +00001352 std::atomic<int> mNumTrustedPresentationListeners = 0;
1353
Lloyd Pique70d91362018-10-18 16:02:55 -07001354 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001355
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05001356 CompositionCoveragePerDisplay mCompositionCoverage;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001357
Garfield Tan9c9c1912021-07-19 12:02:16 -07001358 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1359 // any mutex.
1360 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001361
Lloyd Pique30db6402023-06-26 18:56:51 +00001362 const std::string mHwcServiceName;
1363
Dominik Laskowski068173d2021-08-11 17:22:59 -07001364 std::unique_ptr<scheduler::Scheduler> mScheduler;
Robert Carr720e5062018-07-30 17:45:14 -07001365
Dominik Laskowski80c77272022-07-08 12:47:29 -07001366 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001367
Lloyd Pique30db6402023-06-26 18:56:51 +00001368 bool mLumaSampling = true;
Kevin DuBois413287f2019-02-25 08:46:47 -08001369 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001370 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001371 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Lloyd Pique30db6402023-06-26 18:56:51 +00001372 ui::DisplayPrimaries mInternalDisplayPrimaries;
1373
1374 const float mEmulatedDisplayDensity;
1375 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001376
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001377 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001378 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001379 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001380
Matt Buckley18b93522024-08-27 05:30:18 +00001381 std::unique_ptr<adpf::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001382
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001383 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001384
Sally Qi147581b2023-06-27 11:55:34 -07001385 void enableHdrSdrRatioOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
1386
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001387 // Flag used to set override desired display mode from backdoor
1388 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001389
Melody Hsue524dd92024-08-27 22:27:29 +00001390 // Tracks the number of maximum queued buffers by layer owner Uid.
1391 using BufferStuffingMap = ftl::SmallMap<uid_t, uint32_t, 10>;
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001392 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001393
1394 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1395 GUARDED_BY(mStateLock);
John Reck68796592023-01-25 13:47:12 -05001396
Ady Abraham1273ac12021-08-26 17:31:53 -07001397 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001398
Leon Scroggins III85d4b222023-05-09 13:58:18 -04001399 // Must only be accessed on the main thread.
1400 // TODO (b/259407931): Remove.
1401 static ui::Transform::RotationFlags sActiveDisplayRotationFlags;
1402
Ady Abraham1b11bc62021-06-03 19:51:19 -07001403 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001404 return hasDisplay(
1405 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001406 }
Sally Qi147581b2023-06-27 11:55:34 -07001407 bool isHdrSdrRatioOverlayEnabled() const REQUIRES(mStateLock) {
1408 return hasDisplay(
1409 [](const auto& display) { return display.isHdrSdrRatioOverlayEnabled(); });
1410 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001411 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00001412 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1413 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
1414 snapshotFilterFn);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001415 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Ajinkya Chalke02844632023-03-01 12:10:14 +00001416 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1417 std::unordered_set<uint32_t> excludeLayerIds);
1418 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001419 uint32_t rootLayerId, uint32_t uid, std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07001420 bool childrenOnly, const std::optional<FloatRect>& optionalParentCrop);
Ady Abraham1b11bc62021-06-03 19:51:19 -07001421
chaviw60c9d3e2021-06-04 12:52:17 -05001422 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001423
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001424 // returns the framerate of the layer with the given sequence ID
1425 float getLayerFramerate(nsecs_t now, int32_t id) const {
1426 return mScheduler->getLayerFramerate(now, id);
1427 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001428
Matt Buckley50c44062022-01-17 20:48:10 +00001429 bool mPowerHintSessionEnabled;
Robert Horvathdce110a2022-09-16 11:08:47 +02001430 // Whether a display should be turned on when initialized
1431 bool mSkipPowerOnForQuiescent;
Lloyd Pique30db6402023-06-26 18:56:51 +00001432
Ady Abraham8e3e2ea2024-10-31 15:52:31 -07001433 // used for omitting vsync callbacks to apps when the display is not updatable
1434 int mRefreshableDisplays GUARDED_BY(mStateLock) = 0;
1435 void incRefreshableDisplays() REQUIRES(mStateLock);
1436 void decRefreshableDisplays() REQUIRES(mStateLock);
1437
Vishnu Nair7be27602024-03-28 20:27:09 -07001438 frontend::LayerLifecycleManager mLayerLifecycleManager GUARDED_BY(kMainThreadContext);
1439 frontend::LayerHierarchyBuilder mLayerHierarchyBuilder GUARDED_BY(kMainThreadContext);
1440 frontend::LayerSnapshotBuilder mLayerSnapshotBuilder GUARDED_BY(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001441
Vishnu Naira12c5c72024-08-28 15:42:17 -07001442 mutable std::mutex mCreatedLayersLock;
1443 std::vector<sp<Layer>> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001444 std::vector<std::pair<uint32_t, std::string>> mDestroyedHandles GUARDED_BY(mCreatedLayersLock);
1445 std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers
1446 GUARDED_BY(mCreatedLayersLock);
1447 std::vector<LayerCreationArgs> mNewLayerArgs GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001448 // These classes do not store any client state but help with managing transaction callbacks
1449 // and stats.
Vishnu Nair7be27602024-03-28 20:27:09 -07001450 std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers GUARDED_BY(kMainThreadContext);
Ady Abrahame9ebce02022-02-03 12:05:06 -08001451
Vishnu Nair7be27602024-03-28 20:27:09 -07001452 TransactionHandler mTransactionHandler GUARDED_BY(kMainThreadContext);
1453 ui::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos
1454 GUARDED_BY(kMainThreadContext);
1455 bool mFrontEndDisplayInfosChanged GUARDED_BY(kMainThreadContext) = false;
Patrick Williams1caf3b72023-03-31 10:59:10 -05001456
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05001457 // WindowInfo ids visible during the last commit.
Vishnu Nair7be27602024-03-28 20:27:09 -07001458 std::unordered_set<int32_t> mVisibleWindowIds GUARDED_BY(kMainThreadContext);
Brian Johnson51d8d5d2023-07-28 10:18:47 -07001459
1460 // Mirroring
1461 // Map of displayid to mirrorRoot
1462 ftl::SmallMap<int64_t, sp<SurfaceControl>, 3> mMirrorMapForDebug;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001463
ramindanic67d22c2023-11-28 14:58:47 -08001464 // NotifyExpectedPresentHint
ramindaniae645822024-01-11 10:57:29 -08001465 enum class NotifyExpectedPresentHintStatus {
1466 // Represents that framework can start sending hint if required.
1467 Start,
1468 // Represents that the hint is already sent.
1469 Sent,
1470 // Represents that the hint will be scheduled with a new frame.
1471 ScheduleOnPresent,
1472 // Represents that a hint will be sent instantly by scheduling on the main thread.
1473 ScheduleOnTx
1474 };
ramindanic67d22c2023-11-28 14:58:47 -08001475 struct NotifyExpectedPresentData {
ramindaniae645822024-01-11 10:57:29 -08001476 TimePoint lastExpectedPresentTimestamp{};
ramindanic67d22c2023-11-28 14:58:47 -08001477 Fps lastFrameInterval{};
ramindaniae645822024-01-11 10:57:29 -08001478 // hintStatus is read and write from multiple threads such as
1479 // main thread, EventThread. And is atomic for that reason.
1480 std::atomic<NotifyExpectedPresentHintStatus> hintStatus =
1481 NotifyExpectedPresentHintStatus::Start;
ramindanic67d22c2023-11-28 14:58:47 -08001482 };
1483 std::unordered_map<PhysicalDisplayId, NotifyExpectedPresentData> mNotifyExpectedPresentMap;
ramindaniae645822024-01-11 10:57:29 -08001484 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) override
1485 REQUIRES(kMainThreadContext);
ramindani32a88b12024-01-31 18:45:30 -08001486 void scheduleNotifyExpectedPresentHint(PhysicalDisplayId displayId,
1487 VsyncId vsyncId = VsyncId{
1488 FrameTimelineInfo::INVALID_VSYNC_ID});
ramindanic67d22c2023-11-28 14:58:47 -08001489 void notifyExpectedPresentIfRequired(PhysicalDisplayId, Period vsyncPeriod,
1490 TimePoint expectedPresentTime, Fps frameInterval,
1491 std::optional<Period> timeoutOpt);
1492
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001493 void sfdo_enableRefreshRateOverlay(bool active);
1494 void sfdo_setDebugFlash(int delay);
1495 void sfdo_scheduleComposite();
1496 void sfdo_scheduleCommit();
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001497 void sfdo_forceClientComposition(bool enabled);
Huihong Luof5029222021-12-16 14:33:46 -08001498};
1499
1500class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1501public:
Alan Dingfc6eab52024-05-02 18:28:45 -07001502 explicit SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001503
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001504 binder::Status bootFinished() override;
1505 binder::Status createDisplayEventConnection(
1506 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08001507 const sp<IBinder>& layerHandle,
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001508 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001509 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Alan Dingd53801c2024-05-08 16:45:29 -07001510 binder::Status createVirtualDisplay(const std::string& displayName, bool isSecure,
1511 const std::string& uniqueId, float requestedRefreshRate,
1512 sp<IBinder>* outDisplay) override;
1513 binder::Status destroyVirtualDisplay(const sp<IBinder>& displayToken) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001514 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001515 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001516 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001517 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001518 binder::Status getDisplayStats(const sp<IBinder>& display,
1519 gui::DisplayStatInfo* outStatInfo) override;
1520 binder::Status getDisplayState(const sp<IBinder>& display,
1521 gui::DisplayState* outState) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001522 binder::Status getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08001523 gui::StaticDisplayInfo* outInfo) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001524 binder::Status getDynamicDisplayInfoFromId(int64_t displayId,
1525 gui::DynamicDisplayInfo* outInfo) override;
1526 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
1527 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001528 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1529 gui::DisplayPrimaries* outPrimaries) override;
1530 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1531 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001532 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1533 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001534 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001535 binder::Status getHdrConversionCapabilities(
1536 std::vector<gui::HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +01001537 binder::Status setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
1538 int32_t*) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001539 binder::Status getHdrOutputConversionSupport(bool* outSupport) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001540 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1541 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001542 binder::Status captureDisplay(const DisplayCaptureArgs&,
1543 const sp<IScreenCaptureListener>&) override;
John Reck7e4c4872023-11-14 18:31:03 -05001544 binder::Status captureDisplayById(int64_t, const CaptureArgs&,
1545 const sp<IScreenCaptureListener>&) override;
Huihong Luof5029222021-12-16 14:33:46 -08001546 binder::Status captureLayers(const LayerCaptureArgs&,
1547 const sp<IScreenCaptureListener>&) override;
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00001548 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults* results);
Dominik Laskowski66296b22022-07-12 08:20:36 -07001549
1550 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001551 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1552 return binder::Status::ok();
1553 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001554 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001555 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001556 }
1557
Huihong Luo05539a12022-02-23 10:29:40 -08001558 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1559 const std::vector<int32_t>& hdrTypes) override;
1560 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001561 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1562 binder::Status getDisplayedContentSamplingAttributes(
1563 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1564 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1565 int8_t componentMask,
1566 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001567 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1568 int64_t timestamp,
1569 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001570 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001571 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1572 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001573 binder::Status addRegionSamplingListener(
1574 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1575 const sp<gui::IRegionSamplingListener>& listener) override;
1576 binder::Status removeRegionSamplingListener(
1577 const sp<gui::IRegionSamplingListener>& listener) override;
1578 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1579 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1580 binder::Status addTunnelModeEnabledListener(
1581 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1582 binder::Status removeTunnelModeEnabledListener(
1583 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001584 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1585 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001586 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1587 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001588 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1589 bool* outSupport) override;
1590 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1591 const gui::DisplayBrightness& brightness) override;
1592 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1593 const sp<gui::IHdrLayerInfoListener>& listener) override;
1594 binder::Status removeHdrLayerInfoListener(
1595 const sp<IBinder>& displayToken,
1596 const sp<gui::IHdrLayerInfoListener>& listener) override;
John Reck68796592023-01-25 13:47:12 -05001597
Huihong Luo37396db2022-02-15 10:43:00 -08001598 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001599 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1600 const gui::Color& spotColor, float lightPosY,
1601 float lightPosZ, float lightRadius) override;
1602 binder::Status getDisplayDecorationSupport(
1603 const sp<IBinder>& displayToken,
1604 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
Andy Yu8c2703d2023-11-03 11:22:46 -07001605 binder::Status setGameModeFrameRateOverride(int32_t uid, float frameRate) override;
1606 binder::Status setGameDefaultFrameRateOverride(int32_t uid, float frameRate) override;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001607 binder::Status enableRefreshRateOverlay(bool active) override;
1608 binder::Status setDebugFlash(int delay) override;
1609 binder::Status scheduleComposite() override;
1610 binder::Status scheduleCommit() override;
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001611 binder::Status forceClientComposition(bool enabled) override;
Tony Huangf3621102023-09-04 17:14:22 +08001612 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00001613 const std::vector<float>& thresholds) override;
Tony Huangf3621102023-09-04 17:14:22 +08001614 binder::Status setSmallAreaDetectionThreshold(int32_t appId, float threshold) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001615 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1616 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
Patrick Williamsacd22582023-07-12 13:47:28 -05001617 binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
1618 gui::WindowInfosListenerInfo* outInfo) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001619 binder::Status removeWindowInfosListener(
1620 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Ady Abraham07d03c42023-09-27 19:15:08 -07001621 binder::Status getStalledTransactionInfo(
1622 int pid, std::optional<gui::StalledTransactionInfo>* outInfo) override;
1623 binder::Status getSchedulingPolicy(gui::SchedulingPolicy* outPolicy) override;
Wenhui Yangeafc18a2024-05-14 17:15:52 +00001624 binder::Status notifyShutdown() override;
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001625 binder::Status addJankListener(const sp<IBinder>& layer,
1626 const sp<gui::IJankListener>& listener) override;
1627 binder::Status flushJankData(int32_t layerId) override;
1628 binder::Status removeJankListener(int32_t layerId, const sp<gui::IJankListener>& listener,
1629 int64_t afterVsync) override;
Huihong Luof5029222021-12-16 14:33:46 -08001630
1631private:
Huihong Luo07e72362022-02-14 14:26:04 -08001632 static const constexpr bool kUsePermissionCache = true;
1633 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001634 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001635 status_t checkReadFrameBufferPermission();
Sally Qi6bb12822022-10-05 11:42:30 -07001636 static void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
1637 gui::DynamicDisplayInfo*& outInfo);
Huihong Luo07e72362022-02-14 14:26:04 -08001638
1639private:
Alan Dingfc6eab52024-05-02 18:28:45 -07001640 const sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001641};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001642
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001643} // namespace android