blob: 3cb22741e318913ed18f316a0c42f75f39098924 [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>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080030#include <android/gui/ISurfaceComposerClient.h>
Steven Moreland2716e112018-02-23 14:57:20 -080031#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080032#include <cutils/compiler.h>
Dominik Laskowski80872bd2022-11-15 11:34:33 -050033#include <ftl/algorithm.h>
Dominik Laskowskib17c6212022-05-09 09:36:19 -070034#include <ftl/future.h>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040035#include <ftl/non_null.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080036#include <gui/BufferQueue.h>
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -070037#include <gui/CompositorTiming.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080038#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080039#include <gui/ISurfaceComposer.h>
Huihong Luoffee3bc2023-01-17 16:14:35 +000040#include <gui/ITransactionCompletedListener.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070041#include <gui/LayerState.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080042#include <layerproto/LayerProtoHeader.h>
43#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080044#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070045#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070046#include <system/graphics.h>
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050047#include <ui/DisplayMap.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080048#include <ui/FenceTime.h>
49#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010050#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080051#include <utils/Errors.h>
52#include <utils/KeyedVector.h>
53#include <utils/RefBase.h>
54#include <utils/SortedVector.h>
55#include <utils/Trace.h>
56#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070057
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080058#include <compositionengine/OutputColorSetting.h>
59#include <scheduler/Fps.h>
Dominik Laskowski80c77272022-07-08 12:47:29 -070060#include <scheduler/PresentLatencyTracker.h>
Dominik Laskowski8792c112022-07-12 09:03:39 -070061#include <scheduler/Time.h>
Dominik Laskowski1c99a002023-01-20 17:10:36 -050062#include <scheduler/TransactionSchedule.h>
Dominik Laskowski63f12792023-01-21 16:58:22 -050063#include <scheduler/interface/CompositionCoverage.h>
64#include <scheduler/interface/ICompositor.h>
Patrick Williams2e9748f2022-08-09 22:48:18 +000065#include <ui/FenceResult.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080066
Alec Mouri9b133ca2023-11-14 19:00:01 +000067#include <common/FlagManager.h>
Dominik Laskowski6e465152022-09-28 11:00:25 -040068#include "Display/DisplayModeController.h"
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070069#include "Display/PhysicalDisplay.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070070#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080071#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080072#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020073#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080074#include "Effects/Daltonizer.h"
Vishnu Nairaf6d2972022-11-18 06:26:38 +000075#include "FrontEnd/DisplayInfo.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000076#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000077#include "FrontEnd/LayerLifecycleManager.h"
Vishnu Nair7aa0eb72023-01-24 03:59:27 +000078#include "FrontEnd/LayerSnapshot.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000079#include "FrontEnd/LayerSnapshotBuilder.h"
Vishnu Naira61e4fb2022-10-18 18:29:37 +000080#include "FrontEnd/TransactionHandler.h"
Robert Carr2047fae2016-11-28 14:09:09 -080081#include "LayerVector.h"
Vishnu Naird7ff85f2023-12-08 09:51:31 -080082#include "MutexUtils.h"
Leon Scroggins IIIc275df42023-02-07 16:40:21 -050083#include "Scheduler/ISchedulerCallback.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040084#include "Scheduler/RefreshRateSelector.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070085#include "Scheduler/Scheduler.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080086#include "SurfaceFlingerFactory.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -080087#include "ThreadContext.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070088#include "Tracing/LayerTracing.h"
Vishnu Nair7891e962021-11-11 12:07:21 -080089#include "Tracing/TransactionTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080090#include "TransactionCallbackInvoker.h"
Vishnu Nair6b591152021-10-08 11:45:14 -070091#include "TransactionState.h"
Dominik Laskowskid4a22752024-03-08 17:39:04 -050092#include "Utils/OnceFuture.h"
Mathias Agopian86303202012-07-24 22:46:10 -070093
Dominik Laskowski83b88212018-12-11 13:34:06 -080094#include <atomic>
95#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080096#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070097#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080098#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080099#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700100#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800101#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700102#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -0700103#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -0700104#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -0800105#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700106#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -0700107#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800108#include <utility>
Brian Lindahl439afad2022-11-14 11:16:55 -0700109#include <vector>
Dan Stozae77c7662016-05-13 11:37:28 -0700110
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500111#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Huihong Luo791bef92023-09-19 21:18:45 -0700112#include <aidl/android/hardware/graphics/common/DisplayHotplugEvent.h>
ramindani12bfe6b2023-02-03 13:29:19 -0800113#include <aidl/android/hardware/graphics/composer3/RefreshRateChangedDebugData.h>
Lloyd Pique30db6402023-06-26 18:56:51 +0000114#include "Client.h"
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500115
chaviw1d044282017-09-27 12:19:28 -0700116using namespace android::surfaceflinger;
117
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800118namespace android {
119
Lloyd Pique144e1162017-12-20 16:44:52 -0800120class EventThread;
rnleea2ecd832021-07-29 13:58:30 -0700121class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800122class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200123class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -0400124class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700125class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800126class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800127class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700128class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700129class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700130class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200131class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800132class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700133class FrameTracer;
Huihong Luof5029222021-12-16 14:33:46 -0800134class ScreenCapturer;
chaviw60c9d3e2021-06-04 12:52:17 -0500135class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800136
Huihong Luo791bef92023-09-19 21:18:45 -0700137using ::aidl::android::hardware::graphics::common::DisplayHotplugEvent;
ramindani12bfe6b2023-02-03 13:29:19 -0800138using ::aidl::android::hardware::graphics::composer3::RefreshRateChangedDebugData;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000139using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800140using gui::CaptureArgs;
141using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800142using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800143using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800144using gui::ScreenCaptureResults;
145
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700146namespace frametimeline {
147class FrameTimeline;
148}
149
Chris Ye0783e992020-06-02 21:34:49 -0700150namespace os {
151 class IInputFlinger;
152}
153
Lloyd Pique542307f2018-10-19 13:24:08 -0700154namespace compositionengine {
155class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800156class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800157
158struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700159} // namespace compositionengine
160
Peiyong Lin833074a2018-08-28 11:53:54 -0700161namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800162class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700163} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700164
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800165enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700166 eTransactionNeeded = 0x01,
167 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700168 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700169 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700170 eTransactionFlushNeeded = 0x10,
Patrick Williamsaf06b792023-02-16 17:46:22 -0600171 eInputInfoUpdateNeeded = 0x20,
172 eTransactionMask = 0x3f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800173};
174
Ady Abraham9dada822022-02-03 10:26:59 -0800175// Latch Unsignaled buffer behaviours
176enum class LatchUnsignaledConfig {
177 // All buffers are latched signaled.
178 Disabled,
179
180 // Latch unsignaled is permitted when a single layer is updated in a frame,
181 // and the update includes just a buffer update (i.e. no sync transactions
182 // or geometry changes).
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000183 // Latch unsignaled is also only permitted when a single transaction is ready
184 // to be applied. If we pass an unsignaled fence to HWC, HWC might miss presenting
185 // the frame if the fence does not fire in time. If we apply another transaction,
186 // we may penalize the other transaction unfairly.
Ady Abraham9dada822022-02-03 10:26:59 -0800187 AutoSingleLayer,
188
189 // All buffers are latched unsignaled. This behaviour is discouraged as it
190 // can break sync transactions, stall the display and cause undesired side effects.
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000191 // This is equivalent to ignoring the acquire fence when applying transactions.
Ady Abraham9dada822022-02-03 10:26:59 -0800192 Always,
193};
ramindani4d48f902021-09-20 21:07:45 +0000194
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000195struct DisplayRenderAreaBuilder;
196struct LayerRenderAreaBuilder;
197
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800198using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800199
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700200class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700201 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700202 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800203 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700204 private ICompositor,
jimmyshiu4e211772023-06-15 15:18:38 +0000205 private scheduler::ISchedulerCallback,
ramindaniae645822024-01-11 10:57:29 -0800206 private compositionengine::ICEPowerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800207public:
Lloyd Pique30db6402023-06-26 18:56:51 +0000208 struct SkipInitializationTag {};
209
210 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
211 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700212
213 // set main thread scheduling policy
214 static status_t setSchedFifo(bool enabled) ANDROID_API;
215
Wei Wang23aa5a62021-06-04 15:56:57 -0700216 // set main thread scheduling attributes
217 static status_t setSchedAttr(bool enabled);
218
Peiyong Linf243e5e2020-08-22 17:40:59 -0700219 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800220
Lloyd Pique30db6402023-06-26 18:56:51 +0000221 // If fences from sync Framework are supported.
222 static bool hasSyncFramework;
223
224 // The offset in nanoseconds to use when VsyncController timestamps present fence
225 // signaling time.
226 static int64_t dispSyncPresentTimeOffset;
227
228 // Some hardware can do RGB->YUV conversion more efficiently in hardware
229 // controlled by HWC than in hardware controlled by the video encoder.
230 // This instruct VirtualDisplaySurface to use HWC for such conversion on
231 // GL composition.
232 static bool useHwcForRgbToYuv;
233
234 // Controls the number of buffers SurfaceFlinger will allocate for use in
235 // FramebufferSurface
236 static int64_t maxFrameBufferAcquiredBuffers;
237
238 // Controls the minimum acquired buffers SurfaceFlinger will suggest via
239 // ISurfaceComposer.getMaxAcquiredBufferCount().
240 static int64_t minAcquiredBuffers;
241
242 // Controls the maximum width and height in pixels that the graphics pipeline can support for
243 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
244 static uint32_t maxGraphicsWidth;
245 static uint32_t maxGraphicsHeight;
246
Lloyd Pique30db6402023-06-26 18:56:51 +0000247 static bool useContextPriority;
248
249 // The data space and pixel format that SurfaceFlinger expects hardware composer
250 // to composite efficiently. Meaning under most scenarios, hardware composer
251 // will accept layers with the data space and pixel format.
252 static ui::Dataspace defaultCompositionDataspace;
253 static ui::PixelFormat defaultCompositionPixelFormat;
254
255 // The data space and pixel format that SurfaceFlinger expects hardware composer
256 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
257 // hardware composer will accept layers with the data space and pixel format.
258 static ui::Dataspace wideColorGamutCompositionDataspace;
259 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
260
261 static constexpr SkipInitializationTag SkipInitialization;
262
ramindani4d48f902021-09-20 21:07:45 +0000263 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700264
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700265 // must be called before clients can connect
266 void init() ANDROID_API;
267
268 // starts SurfaceFlinger main loop in the current thread
269 void run() ANDROID_API;
270
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700271 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
272 enum class FrameHint { kNone, kActive };
273
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700274 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700275 void scheduleCommit(FrameHint);
276 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700277 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700278 // As above, but also force dirty geometry to repaint.
279 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700280 // Schedule sampling independently from commit or composite.
281 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800282
Lloyd Pique30db6402023-06-26 18:56:51 +0000283 surfaceflinger::Factory& getFactory() { return mFactory; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700284
Lloyd Pique70d91362018-10-18 16:02:55 -0700285 // The CompositionEngine encapsulates all composition related interfaces and actions.
286 compositionengine::CompositionEngine& getCompositionEngine() const;
287
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700288 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700289
Dominik Laskowski75848362019-11-11 17:57:20 -0800290 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700291 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700292 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700293
Robert Carr867be372021-06-29 17:36:02 -0700294 void removeHierarchyFromOffscreenLayers(Layer* layer);
Valerie Hauc5686802019-11-22 14:18:09 -0800295 void removeFromOffscreenLayers(Layer* layer);
296
Vishnu Nair07e2a482022-10-18 19:18:16 +0000297 // Called when all clients have released all their references to
298 // this layer. The layer may still be kept alive by its parents but
299 // the client can no longer modify this layer directly.
300 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);
301
Vishnu Nair3be61902023-04-26 19:47:29 -0700302 std::vector<Layer*> mLayerMirrorRoots;
Robert Carr6a0382d2021-07-01 15:57:17 -0700303
Robert Carr9a803c32021-01-14 16:57:58 -0800304 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
305 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700306 }
307
Lloyd Pique30db6402023-06-26 18:56:51 +0000308 // If set, disables reusing client composition buffers. This can be set by
309 // debug.sf.disable_client_composition_cache
310 bool mDisableClientCompositionCache = false;
311
Alec Mouridea1ac52021-06-23 18:12:18 -0700312 // Disables expensive rendering for all displays
313 // This is scheduled on the main thread
314 void disableExpensiveRendering();
chaviw79468ab2021-10-27 11:11:24 -0500315 FloatRect getMaxDisplayBounds();
Alec Mouridea1ac52021-06-23 18:12:18 -0700316
Vishnu Naira3140382022-02-24 14:07:11 -0800317 // If set, composition engine tries to predict the composition strategy provided by HWC
318 // based on the previous frame. If the strategy can be predicted, gpu composition will
319 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
320 bool mPredictCompositionStrategy = false;
321
Lloyd Pique30db6402023-06-26 18:56:51 +0000322 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
323 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
324 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
325 // on this behavior to increase contrast for some media sources.
326 bool mTreat170mAsSrgb = false;
327
Alec Mouri9af38ba2023-08-16 22:41:14 +0000328 // If true, then screenshots with an enhanced render intent will dim in gamma space.
329 // The purpose is to ensure that screenshots appear correct during system animations for devices
330 // that require that dimming must occur in gamma space.
331 bool mDimInGammaSpaceForEnhancedScreenshots = false;
332
Lloyd Pique30db6402023-06-26 18:56:51 +0000333 // Allows to ignore physical orientation provided through hwc API in favour of
334 // 'ro.surface_flinger.primary_display_orientation'.
335 // TODO(b/246793311): Clean up a temporary property
336 bool mIgnoreHwcPhysicalDisplayOrientation = false;
337
Chavi Weingarten076acac2023-01-19 17:20:43 +0000338 void forceFutureUpdate(int delayInMs);
Vishnu Nair2f65e972023-04-04 16:36:28 +0000339 const DisplayDevice* getDisplayFromLayerStack(ui::LayerStack)
340 REQUIRES(mStateLock, kMainThreadContext);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000341
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400342 // TODO (b/259407931): Remove.
343 // TODO (b/281857977): This should be annotated with REQUIRES(kMainThreadContext), but this
344 // would require thread safety annotations throughout the frontend (in particular Layer and
345 // LayerFE).
346 static ui::Transform::RotationFlags getActiveDisplayRotationFlags() {
347 return sActiveDisplayRotationFlags;
348 }
349
Peiyong Linf243e5e2020-08-22 17:40:59 -0700350protected:
351 // We're reference counted, never destroy SurfaceFlinger directly
352 virtual ~SurfaceFlinger();
353
Dominik Laskowski263eec42021-07-21 23:13:24 -0700354 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
355 REQUIRES(mStateLock);
356
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800357 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000358 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800359
Dominik Laskowski263eec42021-07-21 23:13:24 -0700360 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
361 template <typename Predicate>
362 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
363 return static_cast<bool>(findDisplay(p));
364 }
365
chaviwba4320c2021-09-15 15:20:53 -0500366 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
367 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
368 }
369
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700370private:
David Sodman0c69cad2017-08-21 12:12:51 -0700371 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700372 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800373 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200374 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700375 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700376 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800377 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800378 friend class LayerRenderArea;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700379 friend class SurfaceComposerAIDL;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000380 friend class DisplayRenderArea;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800381
Lloyd Piquef58625d2017-12-19 13:22:33 -0800382 // For unit tests
383 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700384 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700385 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800386
Peiyong Linf243e5e2020-08-22 17:40:59 -0700387 using TransactionSchedule = scheduler::TransactionSchedule;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000388 using GetLayerSnapshotsFunction = std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>;
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000389 using RenderAreaBuilderVariant = std::variant<DisplayRenderAreaBuilder, LayerRenderAreaBuilder>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700390 using DumpArgs = Vector<String16>;
391 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
392
Robert Carr2047fae2016-11-28 14:09:09 -0800393 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800394 public:
chaviwfd462612018-05-31 16:11:27 -0700395 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700396 State& operator=(const State& other) {
397 // We explicitly don't copy stateSet so that, e.g., mDrawingState
398 // always uses the Drawing StateSet.
399 layersSortedByZ = other.layersSortedByZ;
400 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700401 colorMatrixChanged = other.colorMatrixChanged;
402 if (colorMatrixChanged) {
403 colorMatrix = other.colorMatrix;
404 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800405 globalShadowSettings = other.globalShadowSettings;
406
Dan Stoza412903f2017-04-27 13:42:17 -0700407 return *this;
408 }
409
410 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700411 LayerVector layersSortedByZ;
Dominik Laskowski68399272022-09-15 07:54:46 -0700412
413 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
414 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
415
416 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
417 for (size_t i = 0; i < displays.size(); i++) {
418 const auto& state = displays.valueAt(i);
419 if (state.physical && state.physical->id == displayId) {
420 return i;
421 }
422 }
423
424 return {};
425 }
Robert Carr2047fae2016-11-28 14:09:09 -0800426
Chia-I Wu28f320b2018-05-03 11:02:56 -0700427 bool colorMatrixChanged = true;
428 mat4 colorMatrix;
429
Vishnu Naird9e4f462023-10-06 04:05:45 +0000430 ShadowSettings globalShadowSettings;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800431
Edgar Arriaga844fa672020-01-16 14:21:42 -0800432 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700433 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
434 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800435 };
436
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800437 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
438 // state before the buffers are latched. The layer owns the atomic counters and decrements the
439 // count in the main thread when dropping or latching a buffer.
440 //
441 // The binder threads increment the same counter when a new transaction containing a buffer is
442 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
443 // This is done to avoid lock contention with the main thread.
444 class BufferCountTracker {
445 public:
446 void increment(BBinder* layerHandle) {
447 std::lock_guard<std::mutex> lock(mLock);
448 auto it = mCounterByLayerHandle.find(layerHandle);
449 if (it != mCounterByLayerHandle.end()) {
450 auto [name, pendingBuffers] = it->second;
451 int32_t count = ++(*pendingBuffers);
452 ATRACE_INT(name.c_str(), count);
453 } else {
454 ALOGW("Handle not found! %p", layerHandle);
455 }
456 }
457
458 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
459 std::lock_guard<std::mutex> lock(mLock);
460 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
461 }
462
463 void remove(BBinder* layerHandle) {
464 std::lock_guard<std::mutex> lock(mLock);
465 mCounterByLayerHandle.erase(layerHandle);
466 }
467
468 private:
469 std::mutex mLock;
470 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
471 mCounterByLayerHandle GUARDED_BY(mLock);
472 };
473
Peiyong Linf243e5e2020-08-22 17:40:59 -0700474 enum class BootStage {
475 BOOTLOADER,
476 BOOTANIMATION,
477 FINISHED,
478 };
479
Peiyong Linf243e5e2020-08-22 17:40:59 -0700480 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
481 static Dumper dumper(F&& dump) {
482 using namespace std::placeholders;
483 return std::bind(std::forward<F>(dump), _3);
484 }
485
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800486 Dumper lockedDumper(Dumper dump) {
487 return [this, dump](const DumpArgs& args, bool asProto, std::string& result) -> void {
488 TimedLock lock(mStateLock, s2ns(1), __func__);
489 if (!lock.locked()) {
490 base::StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
491 strerror(-lock.status), lock.status);
492 }
493 dump(args, asProto, result);
494 };
495 }
496
Peiyong Linf243e5e2020-08-22 17:40:59 -0700497 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
498 Dumper dumper(F dump) {
499 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800500 return lockedDumper(std::bind(dump, this, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700501 }
502
503 template <typename F>
504 Dumper argsDumper(F dump) {
505 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800506 return lockedDumper(std::bind(dump, this, _1, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700507 }
508
509 template <typename F>
510 Dumper protoDumper(F dump) {
511 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800512 return lockedDumper(std::bind(dump, this, _1, _2, _3));
513 }
514
Vishnu Naird1a05782024-03-19 04:37:38 +0000515 Dumper mainThreadDumperImpl(Dumper dumper) {
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800516 return [this, dumper](const DumpArgs& args, bool asProto, std::string& result) -> void {
517 mScheduler
518 ->schedule(
519 [&args, asProto, &result, dumper]() FTL_FAKE_GUARD(kMainThreadContext)
520 FTL_FAKE_GUARD(mStateLock) { dumper(args, asProto, result); })
521 .get();
522 };
Peiyong Linf243e5e2020-08-22 17:40:59 -0700523 }
524
Vishnu Naird1a05782024-03-19 04:37:38 +0000525 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
526 Dumper mainThreadDumper(F dump) {
527 using namespace std::placeholders;
528 return mainThreadDumperImpl(std::bind(dump, this, _3));
529 }
530
531 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
532 Dumper argsMainThreadDumper(F dump) {
533 using namespace std::placeholders;
534 return mainThreadDumperImpl(std::bind(dump, this, _1, _3));
535 }
536
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700537 // Maximum allowed number of display frames that can be set through backdoor
538 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700539
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700540 static const size_t MAX_LAYERS = 4096;
541
Alan Dingfc6eab52024-05-02 18:28:45 -0700542 static bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
Steven Thomasd4071902020-03-24 16:02:53 -0700543 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800544
Alan Dingfc6eab52024-05-02 18:28:45 -0700545 // IBinder overrides:
546 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
547 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
548
549 // ISurfaceComposer implementation:
Alan Dingd53801c2024-05-08 16:45:29 -0700550 sp<IBinder> createVirtualDisplay(const std::string& displayName, bool isSecure,
551 const std::string& uniqueId,
552 float requestedRefreshRate = 0.0f);
553 status_t destroyVirtualDisplay(const sp<IBinder>& displayToken);
Huihong Luo07e72362022-02-14 14:26:04 -0800554 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700555 Mutex::Autolock lock(mStateLock);
556 return getPhysicalDisplayIdsLocked();
557 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700558
Huihong Luo07e72362022-02-14 14:26:04 -0800559 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Pablo Gamito23780be2023-04-18 08:30:00 +0000560 status_t setTransactionState(
561 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& state,
562 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
563 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime,
564 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
565 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
566 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700567 void bootFinished();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -0500568 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800569 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700570 gui::ISurfaceComposer::VsyncSource vsyncSource =
571 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
Rachel Lee2248f522023-01-27 16:45:23 -0800572 EventRegistrationFlags eventRegistration = {},
573 const sp<IBinder>& layerHandle = nullptr);
Dominik Laskowskif1833852021-03-23 15:06:50 -0700574
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000575 void captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
John Reck7e4c4872023-11-14 18:31:03 -0500576 void captureDisplay(DisplayId, const CaptureArgs&, const sp<IScreenCaptureListener>&);
Chavi Weingartenf6fb4452024-01-23 21:10:30 +0000577 ScreenCaptureResults captureLayersSync(const LayerCaptureArgs&);
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000578 void captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700579
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800580 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100581 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800582 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700583 status_t getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo*) EXCLUDES(mStateLock);
584 status_t getDynamicDisplayInfoFromId(int64_t displayId, ui::DynamicDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800585 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700586 status_t getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
587 ui::DynamicDisplayInfo*) EXCLUDES(mStateLock);
588 void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*&, const sp<DisplayDevice>&,
589 const display::DisplaySnapshot&);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800590 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
591 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800592 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700593 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700594 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800595 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
Kriti Dang674b9372022-11-18 10:58:44 +0100596 status_t getHdrConversionCapabilities(
597 std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const;
Kriti Dangd432bb52023-02-09 18:21:04 +0100598 status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
599 int32_t*);
Kriti Dang674b9372022-11-18 10:58:44 +0100600 status_t getHdrOutputConversionSupport(bool* outSupport) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800601 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
602 void setGameContentType(const sp<IBinder>& displayToken, bool on);
603 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100604 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800605 const std::vector<ui::Hdr>& hdrTypes);
Huihong Luo30aa4372022-10-03 14:54:12 -0700606 status_t onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData, bool* success);
Peiyong Linc6780972018-10-28 15:24:08 -0700607 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
608 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800609 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700610 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800611 ui::PixelFormat* outFormat,
612 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800613 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700614 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800615 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700616 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800617 uint64_t timestamp, DisplayedFrameStats* outStats) const;
618 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800619 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800620 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800621 const sp<IRegionSamplingListener>& listener);
622 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
623 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
624 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
625 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
626 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100627 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700628 const gui::DisplayModeSpecs&);
629 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800630 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500631 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800632 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400633 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800634 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400635 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800636 const sp<gui::IHdrLayerInfoListener>& listener);
637 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800638 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800639 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500640 status_t getDisplayDecorationSupport(
641 const sp<IBinder>& displayToken,
642 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800643 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800644 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800645 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700646
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000647 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800648 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700649
Andy Yu8c2703d2023-11-03 11:22:46 -0700650 status_t setGameModeFrameRateOverride(uid_t uid, float frameRate);
651
652 status_t setGameDefaultFrameRateOverride(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800653
Tony Huangf3621102023-09-04 17:14:22 +0800654 status_t updateSmallAreaDetection(std::vector<std::pair<int32_t, float>>& uidThresholdMappings);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000655
Tony Huangf3621102023-09-04 17:14:22 +0800656 status_t setSmallAreaDetectionThreshold(int32_t appId, float threshold);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000657
Huihong Luo02186fb2022-02-23 14:21:54 -0800658 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800659
Huihong Luo02186fb2022-02-23 14:21:54 -0800660 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800661
Patrick Williamsacd22582023-07-12 13:47:28 -0500662 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
663 gui::WindowInfosListenerInfo* outResult);
chaviw60c9d3e2021-06-04 12:52:17 -0500664 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800665 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500666
Patrick Williams090ad062023-08-08 12:30:10 -0500667 status_t getStalledTransactionInfo(
668 int pid, std::optional<TransactionHandler::StalledTransactionInfo>& result);
669
Huihong Luo9ebb7a72023-06-27 17:01:50 -0700670 void updateHdcpLevels(hal::HWDisplayId hwcDisplayId, int32_t connectedLevel, int32_t maxLevel);
671
Alan Dingfc6eab52024-05-02 18:28:45 -0700672 // IBinder::DeathRecipient overrides:
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800673 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800674
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700675 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400676 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700677 std::optional<hal::VsyncPeriodNanos>) override;
Huihong Luo791bef92023-09-19 21:18:45 -0700678 void onComposerHalHotplugEvent(hal::HWDisplayId, DisplayHotplugEvent) override;
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700679 void onComposerHalRefresh(hal::HWDisplayId) override;
680 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
681 const hal::VsyncPeriodChangeTimeline&) override;
682 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800683 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
ramindani12bfe6b2023-02-03 13:29:19 -0800684 void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700685
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700686 // ICompositor overrides:
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500687 void configure() override REQUIRES(kMainThreadContext);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400688 bool commit(PhysicalDisplayId pacesetterId, const scheduler::FrameTargets&) override
689 REQUIRES(kMainThreadContext);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500690 CompositeResultsPerDisplay composite(PhysicalDisplayId pacesetterId,
691 const scheduler::FrameTargeters&) override
692 REQUIRES(kMainThreadContext);
693
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700694 void sample() override;
695
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700696 // ISchedulerCallback overrides:
Dominik Laskowski66295432023-03-14 12:25:36 -0400697 void requestHardwareVsync(PhysicalDisplayId, bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400698 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800699 void kernelTimerChanged(bool expired) override;
Ady Abraham62a0be22020-12-08 16:54:10 -0800700 void triggerOnFrameRateOverridesChanged() override;
Ady Abraham822ecbd2023-07-07 16:16:09 -0700701 void onChoreographerAttached() override;
ramindaniae645822024-01-11 10:57:29 -0800702 void onExpectedPresentTimePosted(TimePoint expectedPresentTime, ftl::NonNull<DisplayModePtr>,
703 Fps renderRate) override;
Ady Abraham14beed72024-05-15 17:16:45 -0700704 void onCommitNotComposited(PhysicalDisplayId pacesetterDisplayId) override
705 REQUIRES(kMainThreadContext);
Ady Abrahame2946322024-07-10 17:45:29 -0700706 void vrrDisplayIdle(bool idle) override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700707
jimmyshiu4e211772023-06-15 15:18:38 +0000708 // ICEPowerCallback overrides:
709 void notifyCpuLoadUp() override;
710
Ana Krulecb9afd792020-06-11 13:16:15 -0700711 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
Ady Abraham3efa3942021-06-24 19:01:25 -0700712 void toggleKernelIdleTimer() REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400713
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400714 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400715
ramindani32cf0602022-03-02 02:30:29 +0000716 // Get the controller and timeout that will help decide how the kernel idle timer will be
717 // configured and what value to use as the timeout.
718 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
Dominik Laskowski6e465152022-09-28 11:00:25 -0400719 getKernelIdleTimerProperties(PhysicalDisplayId) REQUIRES(mStateLock);
ramindani32cf0602022-03-02 02:30:29 +0000720 // Updates the kernel idle timer either through HWC or through sysprop
721 // depending on which controller is provided
722 void updateKernelIdleTimer(std::chrono::milliseconds timeoutMs, KernelIdleTimerController,
723 PhysicalDisplayId) REQUIRES(mStateLock);
Ana Krulecb9afd792020-06-11 13:16:15 -0700724 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
725 // make calls to sys prop each time.
726 bool mKernelIdleTimerEnabled = false;
Lloyd Pique30db6402023-06-26 18:56:51 +0000727 // Show spinner with refresh rate overlay
728 bool mRefreshRateOverlaySpinner = false;
729 // Show render rate with refresh rate overlay
730 bool mRefreshRateOverlayRenderRate = false;
731 // Show render rate overlay offseted to the middle of the screen (e.g. for circular displays)
732 bool mRefreshRateOverlayShowInMiddle = false;
Sally Qi147581b2023-06-27 11:55:34 -0700733 // Show hdr sdr ratio overlay
734 bool mHdrSdrRatioOverlay = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700735
Dominik Laskowski88096872023-12-08 15:26:04 -0500736 void setDesiredMode(display::DisplayModeRequest&&) REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400737
Ady Abraham38027262023-10-17 16:58:25 -0700738 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId, Fps minFps,
739 Fps maxFps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400740
Dominik Laskowskia515fd52024-07-15 08:24:49 -0400741 void initiateDisplayModeChanges() REQUIRES(kMainThreadContext) REQUIRES(mStateLock);
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400742 void finalizeDisplayModeChange(PhysicalDisplayId) REQUIRES(kMainThreadContext)
Dominik Laskowskia515fd52024-07-15 08:24:49 -0400743 REQUIRES(mStateLock);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400744
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400745 void dropModeRequest(PhysicalDisplayId) REQUIRES(kMainThreadContext);
746 void applyActiveMode(PhysicalDisplayId) REQUIRES(kMainThreadContext);
Dominik Laskowski59746512023-11-19 09:30:24 -0500747
Marin Shalamanov5801c942020-12-17 17:00:13 +0100748 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700749 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700750 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800751
Dominik Laskowskif2595442022-08-29 13:51:57 -0700752 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
753 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800754 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400755 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700756
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400757 status_t setDesiredDisplayModeSpecsInternal(
758 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700759 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800760
Dominik Laskowski3f726402022-11-21 17:21:22 -0500761 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
762 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
Dominik Laskowski1746afd2024-04-10 19:21:37 -0400763 const scheduler::RefreshRateSelector&)
Dominik Laskowski3f726402022-11-21 17:21:22 -0500764 REQUIRES(mStateLock, kMainThreadContext);
765
Vishnu Nair878911f2024-03-27 22:20:24 -0700766 void commitTransactionsLegacy() EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
767 void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700768 void commitTransactionsLocked(uint32_t transactionFlags)
769 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700770 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800771
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700772 // Returns whether a new buffer has been latched.
773 bool latchBuffers();
Dan Stoza28d46a52020-04-28 09:54:54 -0700774
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700775 void updateLayerGeometry();
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000776 void updateLayerMetadataSnapshot();
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000777 std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(
Vishnu Nair7be27602024-03-28 20:27:09 -0700778 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
779 REQUIRES(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000780 void moveSnapshotsFromCompositionArgs(compositionengine::CompositionRefreshArgs& refreshArgs,
Vishnu Nair7be27602024-03-28 20:27:09 -0700781 const std::vector<std::pair<Layer*, LayerFE*>>& layers)
782 REQUIRES(kMainThreadContext);
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700783 // Return true if we must composite this frame
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000784 bool updateLayerSnapshotsLegacy(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
785 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700786 // Return true if we must composite this frame
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000787 bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000788 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nair7be27602024-03-28 20:27:09 -0700789 void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);
Vishnu Nair81750622023-03-08 15:02:06 -0800790 frontend::Update flushLifecycleUpdates() REQUIRES(kMainThreadContext);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800791
Vishnu Nair7be27602024-03-28 20:27:09 -0700792 void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800793 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800794 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
Vishnu Nair7be27602024-03-28 20:27:09 -0700795 std::vector<gui::DisplayInfo>& outDisplayInfos)
796 REQUIRES(kMainThreadContext);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800797 void commitInputWindowCommands() REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -0700798 void updateCursorAsync() REQUIRES(kMainThreadContext);
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700799
Dominik Laskowski59db9562022-10-27 16:18:53 -0400800 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowski14956dc2023-02-22 13:43:57 -0500801
Peiyong Linf243e5e2020-08-22 17:40:59 -0700802 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700803 * Transactions
804 */
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000805 bool applyTransactionState(const FrameTimelineInfo& info,
806 std::vector<ResolvedComposerState>& state,
807 Vector<DisplayState>& displays, uint32_t flags,
808 const InputWindowCommands& inputWindowCommands,
809 const int64_t desiredPresentTime, bool isAutoTimestamp,
810 const std::vector<uint64_t>& uncacheBufferIds,
811 const int64_t postTime, bool hasListenerCallbacks,
812 const std::vector<ListenerCallbacks>& listenerCallbacks,
813 int originPid, int originUid, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700814 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700815 // Flush pending transactions that were presented after desiredPresentTime.
Vishnu Nair42ad3192023-01-24 19:17:59 -0800816 // For test only
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700817 bool flushTransactionQueues(VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800818
819 bool applyTransactions(std::vector<TransactionState>&, VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair878911f2024-03-27 22:20:24 -0700820 bool applyAndCommitDisplayTransactionStatesLocked(std::vector<TransactionState>& transactions)
821 REQUIRES(kMainThreadContext, mStateLock);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800822
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700823 // Returns true if there is at least one transaction that needs to be flushed
Vishnu Nair7be27602024-03-28 20:27:09 -0700824 bool transactionFlushNeeded() REQUIRES(kMainThreadContext);
825 void addTransactionReadyFilters() REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700826 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
827 const TransactionHandler::TransactionFlushState& flushState)
828 REQUIRES(kMainThreadContext);
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000829 TransactionHandler::TransactionReadiness transactionReadyBufferCheckLegacy(
830 const TransactionHandler::TransactionFlushState& flushState)
831 REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700832 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
833 const TransactionHandler::TransactionFlushState& flushState)
834 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800835
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000836 uint32_t setClientStateLocked(const FrameTimelineInfo&, ResolvedComposerState&,
Dominik Laskowski48e09ef2021-08-04 14:05:30 -0700837 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000838 int64_t postTime, uint64_t transactionId) REQUIRES(mStateLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000839 uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,
840 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000841 int64_t postTime, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700842 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700843 uint32_t getTransactionFlags() const;
844
Dominik Laskowski94000c42022-03-17 12:55:14 -0700845 // Sets the masked bits, and schedules a commit if needed.
846 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700847 const sp<IBinder>& applyToken = nullptr,
848 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700849
850 // Clears and returns the masked bits.
851 uint32_t clearTransactionFlags(uint32_t mask);
852
chaviw74d90ad2019-04-26 14:45:26 -0700853 void commitOffscreenLayers();
Dominik Laskowski94000c42022-03-17 12:55:14 -0700854
ramindani4d48f902021-09-20 21:07:45 +0000855 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000856 bool shouldLatchUnsignaled(const layer_state_t&, size_t numStates, bool firstTransaction) const;
Vishnu Nair42ad3192023-01-24 19:17:59 -0800857 bool applyTransactionsLocked(std::vector<TransactionState>& transactions, VsyncId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700858 REQUIRES(mStateLock, kMainThreadContext);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800859 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800860 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
861 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700862 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
863
Peiyong Linf243e5e2020-08-22 17:40:59 -0700864 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700865 * Layer management
866 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000867 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800868
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800869 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
870 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700871
Vishnu Nair84125ac2021-12-02 08:47:48 -0800872 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800873 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700874
Vishnu Nair84125ac2021-12-02 08:47:48 -0800875 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000876 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700877
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000878 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000879 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000880
Josh Gao194ff392022-09-08 16:19:29 -0700881 void markLayerPendingRemovalLocked(const sp<Layer>& layer) REQUIRES(mStateLock);
Mathias Agopiana4912602012-07-12 14:25:33 -0700882
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700883 // add a layer to SurfaceFlinger
Vishnu Nair1391de22023-03-05 19:56:14 -0800884 status_t addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Naircb8be502022-10-12 19:03:23 +0000885 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700886 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700887
Vishnu Nair4351ad52019-02-11 14:13:02 -0800888 // Traverse through all the layers and compute and cache its bounds.
889 void computeLayerBounds();
890
Melody Hsu793f8362024-01-08 20:00:35 +0000891 // Creates a promise for a future release fence for a layer. This allows for
892 // the layer to keep track of when its buffer can be released.
893 void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
894
895 // Checks if a protected layer exists in a list of layers.
Melody Hsu8c42cf12024-06-05 00:07:03 +0000896 bool layersHasProtectedLayer(const std::vector<sp<LayerFE>>& layers) const;
897
898 using OutputCompositionState = compositionengine::impl::OutputCompositionState;
899
900 std::optional<OutputCompositionState> getDisplayAndLayerSnapshotsFromMainThread(
901 RenderAreaBuilderVariant& renderAreaBuilder,
902 GetLayerSnapshotsFunction getLayerSnapshotsFn, std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu82d524e2024-02-23 02:37:38 +0000903
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000904 void captureScreenCommon(RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
905 ui::Size bufferSize, ui::PixelFormat, bool allowProtected,
906 bool grayscale, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000907
Melody Hsu8c42cf12024-06-05 00:07:03 +0000908 std::optional<OutputCompositionState> getDisplayStateFromRenderAreaBuilder(
909 RenderAreaBuilderVariant& renderAreaBuilder) REQUIRES(kMainThreadContext);
Melody Hsu335ef3e2024-05-31 22:58:40 +0000910
Melody Hsu8c42cf12024-06-05 00:07:03 +0000911 // Legacy layer raw pointer is not safe to access outside the main thread.
912 // Creates a new vector consisting only of LayerFEs, which can be safely
913 // accessed outside the main thread.
914 std::vector<sp<LayerFE>> extractLayerFEs(
915 const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const;
Melody Hsu335ef3e2024-05-31 22:58:40 +0000916
Melody Hsu82d524e2024-02-23 02:37:38 +0000917 ftl::SharedFuture<FenceResult> captureScreenshot(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000918 const RenderAreaBuilderVariant& renderAreaBuilder,
919 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
920 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>& captureListener,
921 std::optional<OutputCompositionState>& displayState,
922 std::vector<sp<LayerFE>>& layerFEs);
923
924 ftl::SharedFuture<FenceResult> captureScreenshotLegacy(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000925 RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000926 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
Chavi Weingarten18fa7c62023-11-28 21:16:03 +0000927 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000928
Melody Hsu793f8362024-01-08 20:00:35 +0000929 ftl::SharedFuture<FenceResult> renderScreenImpl(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000930 std::unique_ptr<const RenderArea>,
Melody Hsu793f8362024-01-08 20:00:35 +0000931 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
932 bool grayscale, bool isProtected, ScreenCaptureResults&,
Melody Hsu8c42cf12024-06-05 00:07:03 +0000933 std::optional<OutputCompositionState>& displayState,
934 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers,
935 std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu793f8362024-01-08 20:00:35 +0000936
Ramakant Singhf7e81912020-04-11 16:02:43 +0530937 bool canAllocateHwcDisplayIdForVDS(uint64_t usage);
938
chaviw4b9d5e12020-08-04 18:30:35 -0700939 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
940 // matching ownerUid
Ajinkya Chalke02844632023-03-01 12:10:14 +0000941 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid,
942 std::unordered_set<uint32_t> excludeLayerIds,
943 const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700944
Romain Guy11d63f42017-07-20 12:47:14 -0700945 void readPersistentProperties();
946
rnleeed20fa42021-08-10 18:00:03 -0700947 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700948
Peiyong Linf243e5e2020-08-22 17:40:59 -0700949 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700950 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700951 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700952
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400953 // Called during boot and restart after system_server death, setting the stage for bootanimation
954 // before DisplayManager takes over.
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400955 void initializeDisplays() REQUIRES(kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700956
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700957 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
958 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700959 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700960 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700961
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700962 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski80872bd2022-11-15 11:34:33 -0500963 return mDisplays.get(displayToken)
964 .or_else(ftl::static_ref<sp<DisplayDevice>>([] { return nullptr; }))
965 .value();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700966 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700967
Ady Abraham690f4612021-07-01 23:24:03 -0700968 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
969 REQUIRES(mStateLock) {
970 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
971 }
972
973 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
974 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
975 return getDisplayDeviceLocked(token);
976 }
977 return nullptr;
978 }
979
Dominik Laskowski3c363242022-04-07 10:44:12 -0700980 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
981 // TODO(b/182939859): Replace tokens with IDs for display lookup.
982 return findDisplay([id](const auto& display) { return display.getId() == id; });
983 }
984
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500985 std::shared_ptr<compositionengine::Display> getCompositionDisplayLocked(DisplayId id) const
986 REQUIRES(mStateLock) {
987 if (const auto display = getDisplayDeviceLocked(id)) {
988 return display->getCompositionDisplay();
989 }
990 return nullptr;
991 }
992
Dominik Laskowski3c363242022-04-07 10:44:12 -0700993 // Returns the primary display or (for foldables) the active display, assuming that the inner
994 // and outer displays have mutually exclusive power states.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700995 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700996 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700997 }
998
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700999 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -07001000 if (const auto display = getDisplayDeviceLocked(mActiveDisplayId)) {
Ady Abrahamed3290f2021-05-17 15:12:14 -07001001 return display;
1002 }
Dominik Laskowski3c363242022-04-07 10:44:12 -07001003 // The active display is outdated, so fall back to the primary display.
Dominik Laskowskie591b552022-09-09 10:44:56 -07001004 mActiveDisplayId = getPrimaryDisplayIdLocked();
1005 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -07001006 }
1007
Ady Abraham3efa3942021-06-24 19:01:25 -07001008 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001009 Mutex::Autolock lock(mStateLock);
1010 return getDefaultDisplayDeviceLocked();
1011 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +02001012
Dominik Laskowski6e465152022-09-28 11:00:25 -04001013 using DisplayDeviceAndSnapshot = std::pair<sp<DisplayDevice>, display::DisplaySnapshotRef>;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001014
1015 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
1016 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
1017 return [this](const display::PhysicalDisplay& display) REQUIRES(
1018 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
1019 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
1020 return std::make_pair(std::move(device), display.snapshotRef());
1021 }
1022
1023 return {};
1024 };
1025 }
1026
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07001027 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
1028 template <typename Predicate>
1029 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
1030 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
Dominik Laskowski3de67272023-08-09 13:15:31 -04001031 [&](const auto& pair)
1032 REQUIRES(mStateLock) { return p(*pair.second); });
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -07001033
1034 return it == mDisplays.end() ? nullptr : it->second;
1035 }
1036
Ady Abrahamed3290f2021-05-17 15:12:14 -07001037 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
1038
Mathias Agopian87baae12012-07-31 12:38:26 -07001039 // mark a region of a layer stack dirty. this updates the dirty
1040 // region of all screens presenting this layer stack.
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001041 void invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -07001042
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001043 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
1044 REQUIRES(mStateLock) {
1045 return {layerStack,
1046 PhysicalDisplayId::tryCast(displayId)
1047 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
1048 .transform(&display::PhysicalDisplay::isInternal)
1049 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -07001050 }
1051
Peiyong Linf243e5e2020-08-22 17:40:59 -07001052 /*
Mathias Agopian86303202012-07-24 22:46:10 -07001053 * H/W composer
1054 */
Marin Shalamanov6e840172020-12-14 22:13:28 +01001055 // The following thread safety rules apply when accessing HWComposer:
1056 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
1057 // acquire mStateLock.
1058 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -07001059 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +01001060 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -07001061 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -07001062
Peiyong Linf243e5e2020-08-22 17:40:59 -07001063 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001064 * Compositing
1065 */
Leon Scroggins III5b581492023-10-31 14:29:41 -04001066 void onCompositionPresented(PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters&,
1067 nsecs_t presentStartTime) REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -07001068
Peiyong Linf243e5e2020-08-22 17:40:59 -07001069 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -07001070 * Display management
1071 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001072 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
1073 REQUIRES(mStateLock);
1074
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001075 // TODO(b/241285876): Move to DisplayConfigurator.
1076 //
1077 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
1078 // commit display transactions.
1079 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
1080 EXCLUDES(mHotplugMutex);
1081
Dominik Laskowski6e465152022-09-28 11:00:25 -04001082 // Returns the active mode ID, or nullopt on hotplug failure.
1083 std::optional<DisplayModeId> processHotplugConnect(PhysicalDisplayId, hal::HWDisplayId,
1084 DisplayIdentificationInfo&&,
1085 const char* displayString)
1086 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb8267b2024-04-26 16:23:07 -04001087 void processHotplugDisconnect(PhysicalDisplayId, const char* displayString)
1088 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07001089
Lloyd Pique542307f2018-10-19 13:24:08 -07001090 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07001091 const wp<IBinder>& displayToken,
1092 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -07001093 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +01001094 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001095 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001096 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001097 void processDisplayRemoved(const wp<IBinder>& displayToken)
1098 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +01001099 void processDisplayChanged(const wp<IBinder>& displayToken,
1100 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001101 const DisplayDeviceState& drawingState)
1102 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001103
Dominik Laskowski5c989f52024-04-11 13:57:14 -04001104 void dispatchDisplayModeChangeEvent(PhysicalDisplayId, const scheduler::FrameRateMode&);
Dominik Laskowski1eba0202019-01-24 09:14:40 -08001105
Peiyong Linf243e5e2020-08-22 17:40:59 -07001106 /*
Dominik Laskowski08d05c22020-07-22 00:05:08 -07001107 * VSYNC
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001108 */
Ady Abraham2492a022020-07-24 11:09:55 -07001109 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -07001110
Dominik Laskowskic2867142019-01-21 11:33:38 -08001111 /*
1112 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001113 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001114 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +02001115 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001116 return mPhysicalDisplays.get(displayId)
1117 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
Dominik Laskowski80872bd2022-11-15 11:34:33 -05001118 .or_else([] { return std::optional<sp<display::DisplayToken>>(nullptr); })
1119 .value();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001120 }
1121
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001122 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001123 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001124
Dominik Laskowski3c363242022-04-07 10:44:12 -07001125 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001126 //
Dominik Laskowski3c363242022-04-07 10:44:12 -07001127 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
1128 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
1129 // display because SF does not support disconnecting it, though in practice HWC may circumvent
1130 // this limitation.)
1131 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
1132 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001133 }
1134
Dominik Laskowski3c363242022-04-07 10:44:12 -07001135 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001136 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001137 }
1138
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001139 // Toggles use of HAL/GPU virtual displays.
1140 void enableHalVirtualDisplays(bool);
1141
1142 // Virtual display lifecycle for ID generation and HAL allocation.
Rajat Yadavbc0c03d2021-07-05 19:32:01 +05301143 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat, bool canAllocateHwcForVDS)
1144 REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001145 void releaseVirtualDisplay(VirtualDisplayId);
1146
Dominik Laskowski3de67272023-08-09 13:15:31 -04001147 // Returns a display other than `mActiveDisplayId` that can be activated, if any.
1148 sp<DisplayDevice> getActivatableDisplay() const REQUIRES(mStateLock, kMainThreadContext);
1149
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001150 void onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
1151 const DisplayDevice& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001152 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001153
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001154 void onActiveDisplaySizeChanged(const DisplayDevice&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001155
Dominik Laskowskic2867142019-01-21 11:33:38 -08001156 /*
1157 * Debugging & dumpsys
1158 */
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001159 void dumpAll(const DumpArgs& args, const std::string& compositionLayers,
1160 std::string& result) const EXCLUDES(mStateLock);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00001161 void dumpHwcLayersMinidump(std::string& result) const REQUIRES(mStateLock, kMainThreadContext);
1162 void dumpHwcLayersMinidumpLockedLegacy(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001163
1164 void appendSfConfigString(std::string& result) const;
Vishnu Nair7be27602024-03-28 20:27:09 -07001165 void listLayers(std::string& result) const REQUIRES(kMainThreadContext);
1166 void dumpStats(const DumpArgs& args, std::string& result) const
1167 REQUIRES(mStateLock, kMainThreadContext);
1168 void clearStats(const DumpArgs& args, std::string& result) REQUIRES(kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001169 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001170 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001171 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001172
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001173 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1174 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1175 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001176
1177 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1178 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001179 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001180 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001181 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
John Reck2a3d29d2023-08-17 17:45:01 -04001182 void dumpHdrInfo(std::string& result) const REQUIRES(mStateLock);
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001183 void dumpFrontEnd(std::string& result) REQUIRES(kMainThreadContext);
1184 void dumpVisibleFrontEnd(std::string& result) REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001185
Vishnu Nair7be27602024-03-28 20:27:09 -07001186 perfetto::protos::LayersProto dumpDrawingStateProto(uint32_t traceFlags) const
1187 REQUIRES(kMainThreadContext);
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001188 void dumpOffscreenLayersProto(perfetto::protos::LayersProto& layersProto,
Vishnu Nair00b90132021-11-05 14:03:40 -07001189 uint32_t traceFlags = LayerTracing::TRACE_ALL) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001190 google::protobuf::RepeatedPtrField<perfetto::protos::DisplayProto> dumpDisplayProto() const;
Kean Mariotti639b54f2023-04-20 12:06:29 +00001191 void doActiveLayersTracingIfNeeded(bool isCompositionComputed, bool visibleRegionDirty,
1192 TimePoint, VsyncId) REQUIRES(kMainThreadContext);
1193 perfetto::protos::LayersSnapshotProto takeLayersSnapshotProto(uint32_t flags, TimePoint,
1194 VsyncId, bool visibleRegionDirty)
Vishnu Nair81750622023-03-08 15:02:06 -08001195 REQUIRES(kMainThreadContext);
chaviw0a398992021-08-13 10:13:01 -05001196
Alec Mouri6b9e9912020-01-21 10:50:24 -08001197 // Dumps state from HW Composer
1198 void dumpHwc(std::string& result) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001199 perfetto::protos::LayersProto dumpProtoFromMainThread(
1200 uint32_t traceFlags = LayerTracing::TRACE_ALL) EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -07001201 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001202 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001203
Dominik Laskowskic2867142019-01-21 11:33:38 -08001204 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1205
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001206 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001207
1208 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1209 return doDump(fd, args, asProto);
1210 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001211
chaviw17ac24b2021-01-28 18:50:05 -08001212 static mat4 calculateColorMatrix(float saturation);
1213
Chia-I Wu28f320b2018-05-03 11:02:56 -07001214 void updateColorMatrixLocked();
1215
Peiyong Linf243e5e2020-08-22 17:40:59 -07001216 // Verify that transaction is being called by an approved process:
1217 // either AID_GRAPHICS or AID_SYSTEM.
1218 status_t CheckTransactCodeCredentials(uint32_t code);
1219
Ady Abrahame46243a2021-02-23 19:33:49 -08001220 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001221
Peiyong Linf243e5e2020-08-22 17:40:59 -07001222 /*
1223 * Generic Layer Metadata
1224 */
1225 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1226
Lloyd Pique30db6402023-06-26 18:56:51 +00001227 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1228 std::chrono::nanoseconds presentLatency);
Ady Abraham899dcdb2021-06-15 16:56:21 -07001229 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001230
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00001231 bool isHdrLayer(const frontend::LayerSnapshot& snapshot) const;
John Reck49d9ad32022-02-23 19:03:31 -05001232
ramindani06e518e2022-03-14 18:47:53 +00001233 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1234 REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001235 void traverseLegacyLayers(const LayerVector::Visitor& visitor) const
1236 REQUIRES(kMainThreadContext);
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001237
1238 void initBootProperties();
Vishnu Nair8c5b7002023-08-17 21:03:57 -07001239 void initTransactionTraceWriter();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001240
Lloyd Pique30db6402023-06-26 18:56:51 +00001241 surfaceflinger::Factory& mFactory;
1242 pid_t mPid;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001243
1244 // TODO: b/328459745 - Encapsulate in a SystemProperties object.
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001245 utils::OnceFuture mInitBootPropsFuture;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001246
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001247 utils::OnceFuture mRenderEnginePrimeCacheFuture;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001248
Leon Scroggins III67388622023-02-06 20:36:20 -05001249 // mStateLock has conventions related to the current thread, because only
1250 // the main thread should modify variables protected by mStateLock.
1251 // - read access from a non-main thread must lock mStateLock, since the main
1252 // thread may modify these variables.
1253 // - write access from a non-main thread is not permitted.
1254 // - read access from the main thread can use an ftl::FakeGuard, since other
1255 // threads must not modify these variables.
1256 // - write access from the main thread must lock mStateLock, since another
1257 // thread may be reading these variables.
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001258 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001259 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001260 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001261 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001262 SortedVector<sp<Layer>> mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001263
Brian Lindahl439afad2022-11-14 11:16:55 -07001264 // Buffers that have been discarded by clients and need to be evicted from per-layer caches so
1265 // the graphics memory can be immediately freed.
1266 std::vector<uint64_t> mBufferIdsToUncache;
1267
Chia-I Wu28f320b2018-05-03 11:02:56 -07001268 // global color transform states
1269 Daltonizer mDaltonizer;
1270 float mGlobalSaturationFactor = 1.0f;
1271 mat4 mClientColorMatrix;
1272
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001273 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001274 bool mLayersRemoved = false;
1275 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001276
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001277 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001278 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001279
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001280 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001281 const nsecs_t mBootTime = systemTime();
Lloyd Pique30db6402023-06-26 18:56:51 +00001282 bool mIsUserBuild = true;
Dominik Laskowskie62606d2024-02-22 11:42:13 -05001283 bool mHasReliablePresentFences = false;
Mathias Agopian3094df32012-06-18 18:06:45 -07001284
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001285 // Can only accessed from the main thread, these members
1286 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001287 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001288 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001289
John Reck68796592023-01-25 13:47:12 -05001290 bool mHdrLayerInfoChanged = false;
1291
Robert Carr167bdde2021-07-28 11:26:51 -07001292 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1293 // scene hasn't changed
1294 bool mAddingHDRLayerInfoListener = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00001295 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001296
Robert Carre450fb52021-06-11 13:21:09 -07001297 // Set during transaction application stage to track if the input info or children
1298 // for a layer has changed.
1299 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001300 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001301 bool mSomeChildrenChanged;
Robert Carrb552ff52021-06-11 13:35:54 -07001302 bool mForceTransactionDisplayChange = false;
Ady Abraham822ecbd2023-07-07 16:16:09 -07001303 bool mUpdateAttachedChoreographer = false;
Robert Carre450fb52021-06-11 13:21:09 -07001304
Vishnu Nair0a4fb002022-08-08 02:40:42 +00001305 // Set if LayerMetadata has changed since the last LayerMetadata snapshot.
1306 bool mLayerMetadataSnapshotNeeded = false;
1307
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001308 // TODO(b/238781169) validate these on composition
Alec Mouri5c9c9602020-09-01 15:10:40 -07001309 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001310 // latched.
Huihong Luoa339d0a2022-02-05 09:42:42 -08001311 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithQueuedFrames;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001312 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;
Vishnu Nair6f209e22023-08-04 16:33:23 +00001313 std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;
1314
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001315 // Tracks layers that need to update a display's dirty region.
1316 std::vector<sp<Layer>> mLayersPendingRefresh;
Vishnu Nair802ac4f2023-05-10 13:55:22 -07001317 // Sorted list of layers that were composed during previous frame. This is used to
1318 // avoid an expensive traversal of the layer hierarchy when there are no
1319 // visible region changes. Because this is a list of strong pointers, this will
1320 // extend the life of the layer but this list is only updated in the main thread.
1321 std::vector<sp<Layer>> mPreviouslyComposedLayers;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001322
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001323 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001324
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001325 struct HotplugEvent {
1326 hal::HWDisplayId hwcDisplayId;
1327 hal::Connection connection = hal::Connection::INVALID;
1328 };
1329
Huihong Luo9ebb7a72023-06-27 17:01:50 -07001330 bool mIsHdcpViaNegVsync = false;
Huihong Luoaac3a772023-09-19 20:51:59 -07001331 bool mIsHotplugErrViaNegVsync = false;
1332
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001333 std::mutex mHotplugMutex;
1334 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001335
Dominik Laskowskieb627312022-04-07 09:13:16 -07001336 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1337 // never removed, so take precedence over external and virtual displays.
1338 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001339 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001340 ui::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001341
1342 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001343
Dominik Laskowskie591b552022-09-09 10:44:56 -07001344 // The inner or outer display for foldables, assuming they have mutually exclusive power states.
Dominik Laskowski5c989f52024-04-11 13:57:14 -04001345 std::atomic<PhysicalDisplayId> mActiveDisplayId;
Dominik Laskowskie591b552022-09-09 10:44:56 -07001346
Dominik Laskowski6e465152022-09-28 11:00:25 -04001347 display::DisplayModeController mDisplayModeController;
1348
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001349 struct {
1350 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1351 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1352 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001353
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001354 std::atomic_uint mDebugFlashDelay = 0;
1355 std::atomic_bool mDebugDisableHWC = false;
1356 std::atomic_bool mDebugDisableTransformHint = false;
1357 std::atomic<nsecs_t> mDebugInTransaction = 0;
1358 std::atomic_bool mForceFullDamage = false;
1359
Lloyd Pique30db6402023-06-26 18:56:51 +00001360 bool mLayerCachingEnabled = false;
1361 bool mBackpressureGpuComposition = false;
1362
Vishnu Nair81750622023-03-08 15:02:06 -08001363 LayerTracing mLayerTracing;
Dominik Laskowski46471e62022-01-14 15:34:03 -08001364 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001365
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001366 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001367 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001368 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001369
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001370 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001371
Lloyd Pique30db6402023-06-26 18:56:51 +00001372 // If blurs should be enabled on this device.
1373 bool mSupportsBlur = false;
1374
Robert Carr9a803c32021-01-14 16:57:58 -08001375 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001376
chaviweadf0d42019-08-12 13:28:29 -07001377 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001378
Steven Morelanda904bb92019-07-02 17:37:23 -07001379 // to linkToDeath
1380 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001381 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1382 // different threads without a lock and could trigger unsynchronized writes to
1383 // to mWindowManager or mInputFlinger
1384 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001385
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001386 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001387
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001388 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001389
Peiyong Lina3ea5592019-02-10 14:45:00 -08001390 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1391 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1392 // 2. be one of the supported color modes returned by hardware composer, otherwise
1393 // it will not be respected.
1394 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1395 // is not set to 1.
1396 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1397 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1398
Lloyd Pique30db6402023-06-26 18:56:51 +00001399 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1400 // If false, wide color modes are filtered out for all internal displays.
1401 bool mSupportsWideColor = false;
Dominik Laskowski788945b2022-08-30 12:10:56 -07001402
Lloyd Pique30db6402023-06-26 18:56:51 +00001403 ui::Dataspace mDefaultCompositionDataspace;
1404 ui::Dataspace mWideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001405
Patrick Williams0a525a42022-10-26 20:20:50 +00001406 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Chavi Weingarten076acac2023-01-19 17:20:43 +00001407 std::atomic<int> mNumTrustedPresentationListeners = 0;
1408
Lloyd Pique70d91362018-10-18 16:02:55 -07001409 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001410
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05001411 CompositionCoveragePerDisplay mCompositionCoverage;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001412
Garfield Tan9c9c1912021-07-19 12:02:16 -07001413 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1414 // any mutex.
1415 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001416
Lloyd Pique30db6402023-06-26 18:56:51 +00001417 const std::string mHwcServiceName;
1418
Dominik Laskowski068173d2021-08-11 17:22:59 -07001419 std::unique_ptr<scheduler::Scheduler> mScheduler;
Robert Carr720e5062018-07-30 17:45:14 -07001420
Dominik Laskowski80c77272022-07-08 12:47:29 -07001421 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001422
Lloyd Pique30db6402023-06-26 18:56:51 +00001423 bool mLumaSampling = true;
Kevin DuBois413287f2019-02-25 08:46:47 -08001424 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001425 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001426 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Lloyd Pique30db6402023-06-26 18:56:51 +00001427 ui::DisplayPrimaries mInternalDisplayPrimaries;
1428
1429 const float mEmulatedDisplayDensity;
1430 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001431
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001432 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001433 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001434 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001435
Xiang Wang839fe5b2022-04-04 17:39:38 +00001436 std::unique_ptr<Hwc2::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001437
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001438 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001439
Sally Qi147581b2023-06-27 11:55:34 -07001440 void enableHdrSdrRatioOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
1441
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001442 // Flag used to set override desired display mode from backdoor
1443 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001444
1445 // A set of layers that have no parent so they are not drawn on screen.
1446 // Should only be accessed by the main thread.
1447 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1448 // be any issues with a raw pointer referencing an invalid object.
1449 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001450
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001451 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001452
1453 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1454 GUARDED_BY(mStateLock);
John Reck68796592023-01-25 13:47:12 -05001455
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001456 mutable std::mutex mCreatedLayersLock;
arthurhungdba591c2021-02-08 17:28:49 +08001457
1458 // A temporay pool that store the created layers and will be added to current state in main
1459 // thread.
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001460 std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001461 bool commitCreatedLayers(VsyncId, std::vector<LayerCreatedState>& createdLayers);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001462 void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001463
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001464 mutable std::mutex mMirrorDisplayLock;
1465 struct MirrorDisplayState {
1466 MirrorDisplayState(ui::LayerStack layerStack, sp<IBinder>& rootHandle,
1467 const sp<Client>& client)
1468 : layerStack(layerStack), rootHandle(rootHandle), client(client) {}
1469
1470 ui::LayerStack layerStack;
1471 sp<IBinder> rootHandle;
1472 const sp<Client> client;
1473 };
1474 std::vector<MirrorDisplayState> mMirrorDisplays GUARDED_BY(mMirrorDisplayLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001475 bool commitMirrorDisplays(VsyncId);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +00001476
Ady Abraham1273ac12021-08-26 17:31:53 -07001477 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001478
Leon Scroggins III85d4b222023-05-09 13:58:18 -04001479 // Must only be accessed on the main thread.
1480 // TODO (b/259407931): Remove.
1481 static ui::Transform::RotationFlags sActiveDisplayRotationFlags;
1482
Ady Abraham1b11bc62021-06-03 19:51:19 -07001483 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001484 return hasDisplay(
1485 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001486 }
Sally Qi147581b2023-06-27 11:55:34 -07001487 bool isHdrSdrRatioOverlayEnabled() const REQUIRES(mStateLock) {
1488 return hasDisplay(
1489 [](const auto& display) { return display.isHdrSdrRatioOverlayEnabled(); });
1490 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001491 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00001492 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1493 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
1494 snapshotFilterFn);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001495 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Ajinkya Chalke02844632023-03-01 12:10:14 +00001496 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1497 std::unordered_set<uint32_t> excludeLayerIds);
1498 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001499 uint32_t rootLayerId, uint32_t uid, std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07001500 bool childrenOnly, const std::optional<FloatRect>& optionalParentCrop);
Ady Abraham1b11bc62021-06-03 19:51:19 -07001501
chaviw60c9d3e2021-06-04 12:52:17 -05001502 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001503
Rheygine Medel9be9d5f2022-05-25 19:20:55 -07001504 bool mAllowHwcForVDS = false;
1505 bool mAllowHwcForWFD = false;
1506
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001507 // returns the framerate of the layer with the given sequence ID
1508 float getLayerFramerate(nsecs_t now, int32_t id) const {
1509 return mScheduler->getLayerFramerate(now, id);
1510 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001511
Matt Buckley50c44062022-01-17 20:48:10 +00001512 bool mPowerHintSessionEnabled;
1513
Lloyd Pique30db6402023-06-26 18:56:51 +00001514 bool mLayerLifecycleManagerEnabled = false;
Robert Horvathdce110a2022-09-16 11:08:47 +02001515 // Whether a display should be turned on when initialized
1516 bool mSkipPowerOnForQuiescent;
Lloyd Pique30db6402023-06-26 18:56:51 +00001517
Vishnu Nair7be27602024-03-28 20:27:09 -07001518 frontend::LayerLifecycleManager mLayerLifecycleManager GUARDED_BY(kMainThreadContext);
1519 frontend::LayerHierarchyBuilder mLayerHierarchyBuilder GUARDED_BY(kMainThreadContext);
1520 frontend::LayerSnapshotBuilder mLayerSnapshotBuilder GUARDED_BY(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001521
Vishnu Nair7be27602024-03-28 20:27:09 -07001522 std::vector<std::pair<uint32_t, std::string>> mDestroyedHandles GUARDED_BY(mCreatedLayersLock);
1523 std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers
1524 GUARDED_BY(mCreatedLayersLock);
1525 std::vector<LayerCreationArgs> mNewLayerArgs GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001526 // These classes do not store any client state but help with managing transaction callbacks
1527 // and stats.
Vishnu Nair7be27602024-03-28 20:27:09 -07001528 std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers GUARDED_BY(kMainThreadContext);
Ady Abrahame9ebce02022-02-03 12:05:06 -08001529
Vishnu Nair7be27602024-03-28 20:27:09 -07001530 TransactionHandler mTransactionHandler GUARDED_BY(kMainThreadContext);
1531 ui::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos
1532 GUARDED_BY(kMainThreadContext);
1533 bool mFrontEndDisplayInfosChanged GUARDED_BY(kMainThreadContext) = false;
Patrick Williams1caf3b72023-03-31 10:59:10 -05001534
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05001535 // WindowInfo ids visible during the last commit.
Vishnu Nair7be27602024-03-28 20:27:09 -07001536 std::unordered_set<int32_t> mVisibleWindowIds GUARDED_BY(kMainThreadContext);
Brian Johnson51d8d5d2023-07-28 10:18:47 -07001537
1538 // Mirroring
1539 // Map of displayid to mirrorRoot
1540 ftl::SmallMap<int64_t, sp<SurfaceControl>, 3> mMirrorMapForDebug;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001541
ramindanic67d22c2023-11-28 14:58:47 -08001542 // NotifyExpectedPresentHint
ramindaniae645822024-01-11 10:57:29 -08001543 enum class NotifyExpectedPresentHintStatus {
1544 // Represents that framework can start sending hint if required.
1545 Start,
1546 // Represents that the hint is already sent.
1547 Sent,
1548 // Represents that the hint will be scheduled with a new frame.
1549 ScheduleOnPresent,
1550 // Represents that a hint will be sent instantly by scheduling on the main thread.
1551 ScheduleOnTx
1552 };
ramindanic67d22c2023-11-28 14:58:47 -08001553 struct NotifyExpectedPresentData {
ramindaniae645822024-01-11 10:57:29 -08001554 TimePoint lastExpectedPresentTimestamp{};
ramindanic67d22c2023-11-28 14:58:47 -08001555 Fps lastFrameInterval{};
ramindaniae645822024-01-11 10:57:29 -08001556 // hintStatus is read and write from multiple threads such as
1557 // main thread, EventThread. And is atomic for that reason.
1558 std::atomic<NotifyExpectedPresentHintStatus> hintStatus =
1559 NotifyExpectedPresentHintStatus::Start;
ramindanic67d22c2023-11-28 14:58:47 -08001560 };
1561 std::unordered_map<PhysicalDisplayId, NotifyExpectedPresentData> mNotifyExpectedPresentMap;
ramindaniae645822024-01-11 10:57:29 -08001562 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) override
1563 REQUIRES(kMainThreadContext);
ramindani32a88b12024-01-31 18:45:30 -08001564 void scheduleNotifyExpectedPresentHint(PhysicalDisplayId displayId,
1565 VsyncId vsyncId = VsyncId{
1566 FrameTimelineInfo::INVALID_VSYNC_ID});
ramindanic67d22c2023-11-28 14:58:47 -08001567 void notifyExpectedPresentIfRequired(PhysicalDisplayId, Period vsyncPeriod,
1568 TimePoint expectedPresentTime, Fps frameInterval,
1569 std::optional<Period> timeoutOpt);
1570
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001571 void sfdo_enableRefreshRateOverlay(bool active);
1572 void sfdo_setDebugFlash(int delay);
1573 void sfdo_scheduleComposite();
1574 void sfdo_scheduleCommit();
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001575 void sfdo_forceClientComposition(bool enabled);
Huihong Luof5029222021-12-16 14:33:46 -08001576};
1577
1578class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1579public:
Alan Dingfc6eab52024-05-02 18:28:45 -07001580 explicit SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001581
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001582 binder::Status bootFinished() override;
1583 binder::Status createDisplayEventConnection(
1584 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08001585 const sp<IBinder>& layerHandle,
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001586 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001587 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Alan Dingd53801c2024-05-08 16:45:29 -07001588 binder::Status createVirtualDisplay(const std::string& displayName, bool isSecure,
1589 const std::string& uniqueId, float requestedRefreshRate,
1590 sp<IBinder>* outDisplay) override;
1591 binder::Status destroyVirtualDisplay(const sp<IBinder>& displayToken) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001592 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001593 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001594 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001595 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001596 binder::Status getDisplayStats(const sp<IBinder>& display,
1597 gui::DisplayStatInfo* outStatInfo) override;
1598 binder::Status getDisplayState(const sp<IBinder>& display,
1599 gui::DisplayState* outState) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001600 binder::Status getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08001601 gui::StaticDisplayInfo* outInfo) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001602 binder::Status getDynamicDisplayInfoFromId(int64_t displayId,
1603 gui::DynamicDisplayInfo* outInfo) override;
1604 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
1605 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001606 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1607 gui::DisplayPrimaries* outPrimaries) override;
1608 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1609 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001610 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1611 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001612 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001613 binder::Status getHdrConversionCapabilities(
1614 std::vector<gui::HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +01001615 binder::Status setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
1616 int32_t*) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001617 binder::Status getHdrOutputConversionSupport(bool* outSupport) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001618 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1619 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001620 binder::Status captureDisplay(const DisplayCaptureArgs&,
1621 const sp<IScreenCaptureListener>&) override;
John Reck7e4c4872023-11-14 18:31:03 -05001622 binder::Status captureDisplayById(int64_t, const CaptureArgs&,
1623 const sp<IScreenCaptureListener>&) override;
Huihong Luof5029222021-12-16 14:33:46 -08001624 binder::Status captureLayers(const LayerCaptureArgs&,
1625 const sp<IScreenCaptureListener>&) override;
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00001626 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults* results);
Dominik Laskowski66296b22022-07-12 08:20:36 -07001627
1628 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001629 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1630 return binder::Status::ok();
1631 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001632 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001633 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001634 }
1635
Huihong Luo05539a12022-02-23 10:29:40 -08001636 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1637 const std::vector<int32_t>& hdrTypes) override;
1638 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001639 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1640 binder::Status getDisplayedContentSamplingAttributes(
1641 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1642 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1643 int8_t componentMask,
1644 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001645 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1646 int64_t timestamp,
1647 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001648 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001649 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1650 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001651 binder::Status addRegionSamplingListener(
1652 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1653 const sp<gui::IRegionSamplingListener>& listener) override;
1654 binder::Status removeRegionSamplingListener(
1655 const sp<gui::IRegionSamplingListener>& listener) override;
1656 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1657 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1658 binder::Status addTunnelModeEnabledListener(
1659 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1660 binder::Status removeTunnelModeEnabledListener(
1661 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001662 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1663 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001664 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1665 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001666 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1667 bool* outSupport) override;
1668 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1669 const gui::DisplayBrightness& brightness) override;
1670 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1671 const sp<gui::IHdrLayerInfoListener>& listener) override;
1672 binder::Status removeHdrLayerInfoListener(
1673 const sp<IBinder>& displayToken,
1674 const sp<gui::IHdrLayerInfoListener>& listener) override;
John Reck68796592023-01-25 13:47:12 -05001675
Huihong Luo37396db2022-02-15 10:43:00 -08001676 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001677 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1678 const gui::Color& spotColor, float lightPosY,
1679 float lightPosZ, float lightRadius) override;
1680 binder::Status getDisplayDecorationSupport(
1681 const sp<IBinder>& displayToken,
1682 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
Andy Yu8c2703d2023-11-03 11:22:46 -07001683 binder::Status setGameModeFrameRateOverride(int32_t uid, float frameRate) override;
1684 binder::Status setGameDefaultFrameRateOverride(int32_t uid, float frameRate) override;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001685 binder::Status enableRefreshRateOverlay(bool active) override;
1686 binder::Status setDebugFlash(int delay) override;
1687 binder::Status scheduleComposite() override;
1688 binder::Status scheduleCommit() override;
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001689 binder::Status forceClientComposition(bool enabled) override;
Tony Huangf3621102023-09-04 17:14:22 +08001690 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00001691 const std::vector<float>& thresholds) override;
Tony Huangf3621102023-09-04 17:14:22 +08001692 binder::Status setSmallAreaDetectionThreshold(int32_t appId, float threshold) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001693 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1694 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
Patrick Williamsacd22582023-07-12 13:47:28 -05001695 binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
1696 gui::WindowInfosListenerInfo* outInfo) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001697 binder::Status removeWindowInfosListener(
1698 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Ady Abraham07d03c42023-09-27 19:15:08 -07001699 binder::Status getStalledTransactionInfo(
1700 int pid, std::optional<gui::StalledTransactionInfo>* outInfo) override;
1701 binder::Status getSchedulingPolicy(gui::SchedulingPolicy* outPolicy) override;
Wenhui Yangeafc18a2024-05-14 17:15:52 +00001702 binder::Status notifyShutdown() override;
Huihong Luof5029222021-12-16 14:33:46 -08001703
1704private:
Huihong Luo07e72362022-02-14 14:26:04 -08001705 static const constexpr bool kUsePermissionCache = true;
1706 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001707 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001708 status_t checkReadFrameBufferPermission();
Sally Qi6bb12822022-10-05 11:42:30 -07001709 static void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
1710 gui::DynamicDisplayInfo*& outInfo);
Huihong Luo07e72362022-02-14 14:26:04 -08001711
1712private:
Alan Dingfc6eab52024-05-02 18:28:45 -07001713 const sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001714};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001715
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001716} // namespace android