blob: 9561c65946251717d40243ce74e84c280798f5b2 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080010 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
Dominik Laskowski9dab3432019-03-27 13:21:10 -070016#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080017
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018#include <sys/types.h>
19
Mathias Agopian3f844832013-08-07 21:24:32 -070020/*
21 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
22 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070023
Vishnu Naird7ff85f2023-12-08 09:51:31 -080024#include <android-base/stringprintf.h>
25#include <android-base/strings.h>
Dominik Laskowski83b88212018-12-11 13:34:06 -080026#include <android-base/thread_annotations.h>
Huihong Luof5029222021-12-16 14:33:46 -080027#include <android/gui/BnSurfaceComposer.h>
Huihong Luoaa7fc2e2022-02-15 10:43:00 -080028#include <android/gui/DisplayStatInfo.h>
29#include <android/gui/DisplayState.h>
Pascal Mütschardd56514e2024-05-24 17:37:13 +020030#include <android/gui/IJankListener.h>
Huihong Luod3d8f8e2022-03-08 14:48:46 -080031#include <android/gui/ISurfaceComposerClient.h>
Vishnu Nairbe0ad902024-06-27 23:38:43 +000032#include <common/trace.h>
Steven Moreland2716e112018-02-23 14:57:20 -080033#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080034#include <cutils/compiler.h>
Dominik Laskowski80872bd2022-11-15 11:34:33 -050035#include <ftl/algorithm.h>
Dominik Laskowskib17c6212022-05-09 09:36:19 -070036#include <ftl/future.h>
Dominik Laskowski530d6bd2022-10-10 16:55:54 -040037#include <ftl/non_null.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080038#include <gui/BufferQueue.h>
Dominik Laskowski5a5e01e2022-07-08 07:52:44 -070039#include <gui/CompositorTiming.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080040#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080041#include <gui/ISurfaceComposer.h>
Huihong Luoffee3bc2023-01-17 16:14:35 +000042#include <gui/ITransactionCompletedListener.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070043#include <gui/LayerState.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080044#include <layerproto/LayerProtoHeader.h>
45#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080046#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070047#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070048#include <system/graphics.h>
Dominik Laskowski6b049ff2023-01-29 15:46:45 -050049#include <ui/DisplayMap.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080050#include <ui/FenceTime.h>
51#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010052#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080053#include <utils/Errors.h>
54#include <utils/KeyedVector.h>
55#include <utils/RefBase.h>
56#include <utils/SortedVector.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080057#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070058
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080059#include <compositionengine/OutputColorSetting.h>
60#include <scheduler/Fps.h>
Dominik Laskowski80c77272022-07-08 12:47:29 -070061#include <scheduler/PresentLatencyTracker.h>
Dominik Laskowski8792c112022-07-12 09:03:39 -070062#include <scheduler/Time.h>
Dominik Laskowski1c99a002023-01-20 17:10:36 -050063#include <scheduler/TransactionSchedule.h>
Dominik Laskowski63f12792023-01-21 16:58:22 -050064#include <scheduler/interface/CompositionCoverage.h>
65#include <scheduler/interface/ICompositor.h>
Patrick Williams2e9748f2022-08-09 22:48:18 +000066#include <ui/FenceResult.h>
Dominik Laskowskif6b4ba62021-11-09 12:46:10 -080067
Alec Mouri9b133ca2023-11-14 19:00:01 +000068#include <common/FlagManager.h>
Dominik Laskowski6e465152022-09-28 11:00:25 -040069#include "Display/DisplayModeController.h"
Dominik Laskowskib363c4c2022-08-02 14:03:41 -070070#include "Display/PhysicalDisplay.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070071#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080072#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080073#include "DisplayHardware/PowerAdvisor.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020074#include "DisplayIdGenerator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080075#include "Effects/Daltonizer.h"
Vishnu Nairaf6d2972022-11-18 06:26:38 +000076#include "FrontEnd/DisplayInfo.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000077#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000078#include "FrontEnd/LayerLifecycleManager.h"
Vishnu Nair7aa0eb72023-01-24 03:59:27 +000079#include "FrontEnd/LayerSnapshot.h"
Vishnu Nair3af0ec02023-02-10 04:13:48 +000080#include "FrontEnd/LayerSnapshotBuilder.h"
Vishnu Naira61e4fb2022-10-18 18:29:37 +000081#include "FrontEnd/TransactionHandler.h"
Robert Carr2047fae2016-11-28 14:09:09 -080082#include "LayerVector.h"
Vishnu Naird7ff85f2023-12-08 09:51:31 -080083#include "MutexUtils.h"
Leon Scroggins IIIc275df42023-02-07 16:40:21 -050084#include "Scheduler/ISchedulerCallback.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040085#include "Scheduler/RefreshRateSelector.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070086#include "Scheduler/Scheduler.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080087#include "SurfaceFlingerFactory.h"
Dominik Laskowski298b08e2022-02-15 13:45:02 -080088#include "ThreadContext.h"
Vishnu Nair00b90132021-11-05 14:03:40 -070089#include "Tracing/LayerTracing.h"
Vishnu Nair7891e962021-11-11 12:07:21 -080090#include "Tracing/TransactionTracing.h"
Robert Carr9a803c32021-01-14 16:57:58 -080091#include "TransactionCallbackInvoker.h"
Vishnu Nair6b591152021-10-08 11:45:14 -070092#include "TransactionState.h"
Dominik Laskowskid4a22752024-03-08 17:39:04 -050093#include "Utils/OnceFuture.h"
Mathias Agopian86303202012-07-24 22:46:10 -070094
Dominik Laskowski83b88212018-12-11 13:34:06 -080095#include <atomic>
96#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080097#include <functional>
Dan Stozae77c7662016-05-13 11:37:28 -070098#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080099#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800100#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -0700101#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800102#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700103#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -0700104#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -0700105#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -0800106#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -0700107#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -0700108#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800109#include <utility>
Brian Lindahl439afad2022-11-14 11:16:55 -0700110#include <vector>
Dan Stozae77c7662016-05-13 11:37:28 -0700111
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500112#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
Huihong Luo791bef92023-09-19 21:18:45 -0700113#include <aidl/android/hardware/graphics/common/DisplayHotplugEvent.h>
ramindani12bfe6b2023-02-03 13:29:19 -0800114#include <aidl/android/hardware/graphics/composer3/RefreshRateChangedDebugData.h>
Lloyd Pique30db6402023-06-26 18:56:51 +0000115#include "Client.h"
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500116
chaviw1d044282017-09-27 12:19:28 -0700117using namespace android::surfaceflinger;
118
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800119namespace android {
120
Lloyd Pique144e1162017-12-20 16:44:52 -0800121class EventThread;
rnleea2ecd832021-07-29 13:58:30 -0700122class FlagManager;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800123class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200124class TunnelModeEnabledReporter;
John Reck88270902021-03-18 11:27:35 -0400125class HdrLayerInfoReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700126class HWComposer;
Lloyd Pique12eb4232018-01-17 11:54:43 -0800127class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800128class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700129class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700130class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700131class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +0200132class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800133class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -0700134class FrameTracer;
Huihong Luof5029222021-12-16 14:33:46 -0800135class ScreenCapturer;
chaviw60c9d3e2021-06-04 12:52:17 -0500136class WindowInfosListenerInvoker;
Lloyd Pique144e1162017-12-20 16:44:52 -0800137
Huihong Luo817ebb82023-12-13 12:54:24 -0800138using ::aidl::android::hardware::drm::HdcpLevels;
Huihong Luo791bef92023-09-19 21:18:45 -0700139using ::aidl::android::hardware::graphics::common::DisplayHotplugEvent;
ramindani12bfe6b2023-02-03 13:29:19 -0800140using ::aidl::android::hardware::graphics::composer3::RefreshRateChangedDebugData;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000141using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800142using gui::CaptureArgs;
143using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800144using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800145using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800146using gui::ScreenCaptureResults;
147
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700148namespace frametimeline {
149class FrameTimeline;
150}
151
Chris Ye0783e992020-06-02 21:34:49 -0700152namespace os {
153 class IInputFlinger;
154}
155
Lloyd Pique542307f2018-10-19 13:24:08 -0700156namespace compositionengine {
157class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800158class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800159
160struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700161} // namespace compositionengine
162
Peiyong Lin833074a2018-08-28 11:53:54 -0700163namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800164class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700165} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700166
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800167enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700168 eTransactionNeeded = 0x01,
169 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700170 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700171 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700172 eTransactionFlushNeeded = 0x10,
Patrick Williamsaf06b792023-02-16 17:46:22 -0600173 eInputInfoUpdateNeeded = 0x20,
174 eTransactionMask = 0x3f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800175};
176
Ady Abraham9dada822022-02-03 10:26:59 -0800177// Latch Unsignaled buffer behaviours
178enum class LatchUnsignaledConfig {
179 // All buffers are latched signaled.
180 Disabled,
181
182 // Latch unsignaled is permitted when a single layer is updated in a frame,
183 // and the update includes just a buffer update (i.e. no sync transactions
184 // or geometry changes).
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000185 // Latch unsignaled is also only permitted when a single transaction is ready
186 // to be applied. If we pass an unsignaled fence to HWC, HWC might miss presenting
187 // the frame if the fence does not fire in time. If we apply another transaction,
188 // we may penalize the other transaction unfairly.
Ady Abraham9dada822022-02-03 10:26:59 -0800189 AutoSingleLayer,
190
191 // All buffers are latched unsignaled. This behaviour is discouraged as it
192 // can break sync transactions, stall the display and cause undesired side effects.
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000193 // This is equivalent to ignoring the acquire fence when applying transactions.
Ady Abraham9dada822022-02-03 10:26:59 -0800194 Always,
195};
ramindani4d48f902021-09-20 21:07:45 +0000196
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000197struct DisplayRenderAreaBuilder;
198struct LayerRenderAreaBuilder;
199
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800200using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800201
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700202class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700203 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700204 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800205 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700206 private ICompositor,
jimmyshiu4e211772023-06-15 15:18:38 +0000207 private scheduler::ISchedulerCallback,
ramindaniae645822024-01-11 10:57:29 -0800208 private compositionengine::ICEPowerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800209public:
Lloyd Pique30db6402023-06-26 18:56:51 +0000210 struct SkipInitializationTag {};
211
212 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
213 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700214
215 // set main thread scheduling policy
216 static status_t setSchedFifo(bool enabled) ANDROID_API;
217
Wei Wang23aa5a62021-06-04 15:56:57 -0700218 // set main thread scheduling attributes
219 static status_t setSchedAttr(bool enabled);
220
Peiyong Linf243e5e2020-08-22 17:40:59 -0700221 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800222
Lloyd Pique30db6402023-06-26 18:56:51 +0000223 // If fences from sync Framework are supported.
224 static bool hasSyncFramework;
225
226 // The offset in nanoseconds to use when VsyncController timestamps present fence
227 // signaling time.
228 static int64_t dispSyncPresentTimeOffset;
229
230 // Some hardware can do RGB->YUV conversion more efficiently in hardware
231 // controlled by HWC than in hardware controlled by the video encoder.
232 // This instruct VirtualDisplaySurface to use HWC for such conversion on
233 // GL composition.
234 static bool useHwcForRgbToYuv;
235
236 // Controls the number of buffers SurfaceFlinger will allocate for use in
237 // FramebufferSurface
238 static int64_t maxFrameBufferAcquiredBuffers;
239
240 // Controls the minimum acquired buffers SurfaceFlinger will suggest via
241 // ISurfaceComposer.getMaxAcquiredBufferCount().
242 static int64_t minAcquiredBuffers;
243
244 // Controls the maximum width and height in pixels that the graphics pipeline can support for
245 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
246 static uint32_t maxGraphicsWidth;
247 static uint32_t maxGraphicsHeight;
248
Lloyd Pique30db6402023-06-26 18:56:51 +0000249 static bool useContextPriority;
250
251 // The data space and pixel format that SurfaceFlinger expects hardware composer
252 // to composite efficiently. Meaning under most scenarios, hardware composer
253 // will accept layers with the data space and pixel format.
254 static ui::Dataspace defaultCompositionDataspace;
255 static ui::PixelFormat defaultCompositionPixelFormat;
256
257 // The data space and pixel format that SurfaceFlinger expects hardware composer
258 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
259 // hardware composer will accept layers with the data space and pixel format.
260 static ui::Dataspace wideColorGamutCompositionDataspace;
261 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
262
263 static constexpr SkipInitializationTag SkipInitialization;
264
ramindani4d48f902021-09-20 21:07:45 +0000265 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700266
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700267 // must be called before clients can connect
268 void init() ANDROID_API;
269
270 // starts SurfaceFlinger main loop in the current thread
271 void run() ANDROID_API;
272
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700273 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
274 enum class FrameHint { kNone, kActive };
275
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700276 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Ady Abraham9953e062024-07-24 22:56:22 -0700277 void scheduleCommit(FrameHint, Duration workDurationSlack = Duration::fromNs(0));
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700278 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700279 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700280 // As above, but also force dirty geometry to repaint.
281 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700282 // Schedule sampling independently from commit or composite.
283 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800284
Lloyd Pique30db6402023-06-26 18:56:51 +0000285 surfaceflinger::Factory& getFactory() { return mFactory; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700286
Lloyd Pique70d91362018-10-18 16:02:55 -0700287 // The CompositionEngine encapsulates all composition related interfaces and actions.
288 compositionengine::CompositionEngine& getCompositionEngine() const;
289
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700290 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700291
Dominik Laskowski75848362019-11-11 17:57:20 -0800292 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700293 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700294 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700295
Robert Carr867be372021-06-29 17:36:02 -0700296 void removeHierarchyFromOffscreenLayers(Layer* layer);
Valerie Hauc5686802019-11-22 14:18:09 -0800297 void removeFromOffscreenLayers(Layer* layer);
298
Vishnu Nair07e2a482022-10-18 19:18:16 +0000299 // Called when all clients have released all their references to
300 // this layer. The layer may still be kept alive by its parents but
301 // the client can no longer modify this layer directly.
302 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);
303
Vishnu Nair3be61902023-04-26 19:47:29 -0700304 std::vector<Layer*> mLayerMirrorRoots;
Robert Carr6a0382d2021-07-01 15:57:17 -0700305
Robert Carr9a803c32021-01-14 16:57:58 -0800306 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
307 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700308 }
309
Lloyd Pique30db6402023-06-26 18:56:51 +0000310 // If set, disables reusing client composition buffers. This can be set by
311 // debug.sf.disable_client_composition_cache
312 bool mDisableClientCompositionCache = false;
313
Alec Mouridea1ac52021-06-23 18:12:18 -0700314 // Disables expensive rendering for all displays
315 // This is scheduled on the main thread
316 void disableExpensiveRendering();
317
Vishnu Naira3140382022-02-24 14:07:11 -0800318 // If set, composition engine tries to predict the composition strategy provided by HWC
319 // based on the previous frame. If the strategy can be predicted, gpu composition will
320 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
321 bool mPredictCompositionStrategy = false;
322
Lloyd Pique30db6402023-06-26 18:56:51 +0000323 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
324 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
325 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
326 // on this behavior to increase contrast for some media sources.
327 bool mTreat170mAsSrgb = false;
328
Alec Mouri9af38ba2023-08-16 22:41:14 +0000329 // If true, then screenshots with an enhanced render intent will dim in gamma space.
330 // The purpose is to ensure that screenshots appear correct during system animations for devices
331 // that require that dimming must occur in gamma space.
332 bool mDimInGammaSpaceForEnhancedScreenshots = false;
333
Lloyd Pique30db6402023-06-26 18:56:51 +0000334 // Allows to ignore physical orientation provided through hwc API in favour of
335 // 'ro.surface_flinger.primary_display_orientation'.
336 // TODO(b/246793311): Clean up a temporary property
337 bool mIgnoreHwcPhysicalDisplayOrientation = false;
338
Chavi Weingarten076acac2023-01-19 17:20:43 +0000339 void forceFutureUpdate(int delayInMs);
Vishnu Nair2f65e972023-04-04 16:36:28 +0000340 const DisplayDevice* getDisplayFromLayerStack(ui::LayerStack)
341 REQUIRES(mStateLock, kMainThreadContext);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000342
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400343 // TODO (b/259407931): Remove.
344 // TODO (b/281857977): This should be annotated with REQUIRES(kMainThreadContext), but this
345 // would require thread safety annotations throughout the frontend (in particular Layer and
346 // LayerFE).
347 static ui::Transform::RotationFlags getActiveDisplayRotationFlags() {
348 return sActiveDisplayRotationFlags;
349 }
350
Peiyong Linf243e5e2020-08-22 17:40:59 -0700351protected:
352 // We're reference counted, never destroy SurfaceFlinger directly
353 virtual ~SurfaceFlinger();
354
Dominik Laskowski263eec42021-07-21 23:13:24 -0700355 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
356 REQUIRES(mStateLock);
357
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800358 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000359 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800360
Dominik Laskowski263eec42021-07-21 23:13:24 -0700361 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
362 template <typename Predicate>
363 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
364 return static_cast<bool>(findDisplay(p));
365 }
366
chaviwba4320c2021-09-15 15:20:53 -0500367 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
368 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
369 }
370
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700371private:
David Sodman0c69cad2017-08-21 12:12:51 -0700372 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700373 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800374 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200375 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700376 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700377 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800378 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800379 friend class LayerRenderArea;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700380 friend class SurfaceComposerAIDL;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000381 friend class DisplayRenderArea;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800382
Lloyd Piquef58625d2017-12-19 13:22:33 -0800383 // For unit tests
384 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700385 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700386 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800387
Peiyong Linf243e5e2020-08-22 17:40:59 -0700388 using TransactionSchedule = scheduler::TransactionSchedule;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000389 using GetLayerSnapshotsFunction = std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>;
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000390 using RenderAreaBuilderVariant = std::variant<DisplayRenderAreaBuilder, LayerRenderAreaBuilder>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700391 using DumpArgs = Vector<String16>;
392 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
393
Robert Carr2047fae2016-11-28 14:09:09 -0800394 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800395 public:
chaviwfd462612018-05-31 16:11:27 -0700396 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700397 State& operator=(const State& other) {
398 // We explicitly don't copy stateSet so that, e.g., mDrawingState
399 // always uses the Drawing StateSet.
400 layersSortedByZ = other.layersSortedByZ;
401 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700402 colorMatrixChanged = other.colorMatrixChanged;
403 if (colorMatrixChanged) {
404 colorMatrix = other.colorMatrix;
405 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800406 globalShadowSettings = other.globalShadowSettings;
407
Dan Stoza412903f2017-04-27 13:42:17 -0700408 return *this;
409 }
410
411 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700412 LayerVector layersSortedByZ;
Dominik Laskowski68399272022-09-15 07:54:46 -0700413
414 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
415 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
416
417 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
418 for (size_t i = 0; i < displays.size(); i++) {
419 const auto& state = displays.valueAt(i);
420 if (state.physical && state.physical->id == displayId) {
421 return i;
422 }
423 }
424
425 return {};
426 }
Robert Carr2047fae2016-11-28 14:09:09 -0800427
Chia-I Wu28f320b2018-05-03 11:02:56 -0700428 bool colorMatrixChanged = true;
429 mat4 colorMatrix;
430
Vishnu Naird9e4f462023-10-06 04:05:45 +0000431 ShadowSettings globalShadowSettings;
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800432
Edgar Arriaga844fa672020-01-16 14:21:42 -0800433 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700434 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
435 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800436 };
437
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800438 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
439 // state before the buffers are latched. The layer owns the atomic counters and decrements the
440 // count in the main thread when dropping or latching a buffer.
441 //
442 // The binder threads increment the same counter when a new transaction containing a buffer is
443 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
444 // This is done to avoid lock contention with the main thread.
445 class BufferCountTracker {
446 public:
447 void increment(BBinder* layerHandle) {
448 std::lock_guard<std::mutex> lock(mLock);
449 auto it = mCounterByLayerHandle.find(layerHandle);
450 if (it != mCounterByLayerHandle.end()) {
451 auto [name, pendingBuffers] = it->second;
452 int32_t count = ++(*pendingBuffers);
Vishnu Nairbe0ad902024-06-27 23:38:43 +0000453 SFTRACE_INT(name.c_str(), count);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800454 } else {
455 ALOGW("Handle not found! %p", layerHandle);
456 }
457 }
458
459 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
460 std::lock_guard<std::mutex> lock(mLock);
461 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
462 }
463
464 void remove(BBinder* layerHandle) {
465 std::lock_guard<std::mutex> lock(mLock);
466 mCounterByLayerHandle.erase(layerHandle);
467 }
468
469 private:
470 std::mutex mLock;
471 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
472 mCounterByLayerHandle GUARDED_BY(mLock);
473 };
474
Peiyong Linf243e5e2020-08-22 17:40:59 -0700475 enum class BootStage {
476 BOOTLOADER,
477 BOOTANIMATION,
478 FINISHED,
479 };
480
Peiyong Linf243e5e2020-08-22 17:40:59 -0700481 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
482 static Dumper dumper(F&& dump) {
483 using namespace std::placeholders;
484 return std::bind(std::forward<F>(dump), _3);
485 }
486
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800487 Dumper lockedDumper(Dumper dump) {
488 return [this, dump](const DumpArgs& args, bool asProto, std::string& result) -> void {
489 TimedLock lock(mStateLock, s2ns(1), __func__);
490 if (!lock.locked()) {
491 base::StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
492 strerror(-lock.status), lock.status);
493 }
494 dump(args, asProto, result);
495 };
496 }
497
Peiyong Linf243e5e2020-08-22 17:40:59 -0700498 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
499 Dumper dumper(F dump) {
500 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800501 return lockedDumper(std::bind(dump, this, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700502 }
503
504 template <typename F>
505 Dumper argsDumper(F dump) {
506 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800507 return lockedDumper(std::bind(dump, this, _1, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700508 }
509
510 template <typename F>
511 Dumper protoDumper(F dump) {
512 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800513 return lockedDumper(std::bind(dump, this, _1, _2, _3));
514 }
515
Vishnu Naird1a05782024-03-19 04:37:38 +0000516 Dumper mainThreadDumperImpl(Dumper dumper) {
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800517 return [this, dumper](const DumpArgs& args, bool asProto, std::string& result) -> void {
518 mScheduler
519 ->schedule(
520 [&args, asProto, &result, dumper]() FTL_FAKE_GUARD(kMainThreadContext)
521 FTL_FAKE_GUARD(mStateLock) { dumper(args, asProto, result); })
522 .get();
523 };
Peiyong Linf243e5e2020-08-22 17:40:59 -0700524 }
525
Vishnu Naird1a05782024-03-19 04:37:38 +0000526 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
527 Dumper mainThreadDumper(F dump) {
528 using namespace std::placeholders;
529 return mainThreadDumperImpl(std::bind(dump, this, _3));
530 }
531
532 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
533 Dumper argsMainThreadDumper(F dump) {
534 using namespace std::placeholders;
535 return mainThreadDumperImpl(std::bind(dump, this, _1, _3));
536 }
537
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700538 // Maximum allowed number of display frames that can be set through backdoor
539 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700540
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700541 static const size_t MAX_LAYERS = 4096;
542
Alan Dingfc6eab52024-05-02 18:28:45 -0700543 static bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
Steven Thomasd4071902020-03-24 16:02:53 -0700544 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800545
Alan Dingfc6eab52024-05-02 18:28:45 -0700546 // IBinder overrides:
547 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
548 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
549
550 // ISurfaceComposer implementation:
Alan Dingd53801c2024-05-08 16:45:29 -0700551 sp<IBinder> createVirtualDisplay(const std::string& displayName, bool isSecure,
552 const std::string& uniqueId,
553 float requestedRefreshRate = 0.0f);
554 status_t destroyVirtualDisplay(const sp<IBinder>& displayToken);
Huihong Luo07e72362022-02-14 14:26:04 -0800555 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700556 Mutex::Autolock lock(mStateLock);
557 return getPhysicalDisplayIdsLocked();
558 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700559
Huihong Luo07e72362022-02-14 14:26:04 -0800560 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Pablo Gamito23780be2023-04-18 08:30:00 +0000561 status_t setTransactionState(
562 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& state,
Patrick Williamsf65da8a2024-07-24 17:11:19 +0000563 Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
Pablo Gamito23780be2023-04-18 08:30:00 +0000564 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime,
565 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
566 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
567 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700568 void bootFinished();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -0500569 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800570 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700571 gui::ISurfaceComposer::VsyncSource vsyncSource =
572 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
Rachel Lee2248f522023-01-27 16:45:23 -0800573 EventRegistrationFlags eventRegistration = {},
574 const sp<IBinder>& layerHandle = nullptr);
Dominik Laskowskif1833852021-03-23 15:06:50 -0700575
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000576 void captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
John Reck7e4c4872023-11-14 18:31:03 -0500577 void captureDisplay(DisplayId, const CaptureArgs&, const sp<IScreenCaptureListener>&);
Chavi Weingartenf6fb4452024-01-23 21:10:30 +0000578 ScreenCaptureResults captureLayersSync(const LayerCaptureArgs&);
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000579 void captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700580
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800581 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100582 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800583 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700584 status_t getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo*) EXCLUDES(mStateLock);
585 status_t getDynamicDisplayInfoFromId(int64_t displayId, ui::DynamicDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800586 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700587 status_t getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
588 ui::DynamicDisplayInfo*) EXCLUDES(mStateLock);
589 void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*&, const sp<DisplayDevice>&,
590 const display::DisplaySnapshot&);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800591 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
592 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800593 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700594 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700595 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800596 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
Kriti Dang674b9372022-11-18 10:58:44 +0100597 status_t getHdrConversionCapabilities(
598 std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const;
Kriti Dangd432bb52023-02-09 18:21:04 +0100599 status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
600 int32_t*);
Kriti Dang674b9372022-11-18 10:58:44 +0100601 status_t getHdrOutputConversionSupport(bool* outSupport) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800602 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
603 void setGameContentType(const sp<IBinder>& displayToken, bool on);
604 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100605 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800606 const std::vector<ui::Hdr>& hdrTypes);
Huihong Luo30aa4372022-10-03 14:54:12 -0700607 status_t onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData, bool* success);
Peiyong Linc6780972018-10-28 15:24:08 -0700608 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
609 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800610 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700611 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800612 ui::PixelFormat* outFormat,
613 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800614 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700615 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800616 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700617 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800618 uint64_t timestamp, DisplayedFrameStats* outStats) const;
619 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800620 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800621 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800622 const sp<IRegionSamplingListener>& listener);
623 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
624 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
625 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
626 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
627 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100628 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700629 const gui::DisplayModeSpecs&);
630 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800631 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500632 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800633 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400634 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800635 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400636 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800637 const sp<gui::IHdrLayerInfoListener>& listener);
638 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800639 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800640 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500641 status_t getDisplayDecorationSupport(
642 const sp<IBinder>& displayToken,
643 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800644 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800645 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800646 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700647
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000648 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800649 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700650
Andy Yu8c2703d2023-11-03 11:22:46 -0700651 status_t setGameModeFrameRateOverride(uid_t uid, float frameRate);
652
653 status_t setGameDefaultFrameRateOverride(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800654
Tony Huangf3621102023-09-04 17:14:22 +0800655 status_t updateSmallAreaDetection(std::vector<std::pair<int32_t, float>>& uidThresholdMappings);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000656
Tony Huangf3621102023-09-04 17:14:22 +0800657 status_t setSmallAreaDetectionThreshold(int32_t appId, float threshold);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000658
Huihong Luo02186fb2022-02-23 14:21:54 -0800659 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800660
Huihong Luo02186fb2022-02-23 14:21:54 -0800661 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800662
Patrick Williamsacd22582023-07-12 13:47:28 -0500663 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
664 gui::WindowInfosListenerInfo* outResult);
chaviw60c9d3e2021-06-04 12:52:17 -0500665 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800666 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500667
Patrick Williams090ad062023-08-08 12:30:10 -0500668 status_t getStalledTransactionInfo(
669 int pid, std::optional<TransactionHandler::StalledTransactionInfo>& result);
670
Huihong Luo9ebb7a72023-06-27 17:01:50 -0700671 void updateHdcpLevels(hal::HWDisplayId hwcDisplayId, int32_t connectedLevel, int32_t maxLevel);
672
Alan Dingfc6eab52024-05-02 18:28:45 -0700673 // IBinder::DeathRecipient overrides:
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800674 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800675
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700676 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400677 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700678 std::optional<hal::VsyncPeriodNanos>) override;
Huihong Luo791bef92023-09-19 21:18:45 -0700679 void onComposerHalHotplugEvent(hal::HWDisplayId, DisplayHotplugEvent) override;
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700680 void onComposerHalRefresh(hal::HWDisplayId) override;
681 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
682 const hal::VsyncPeriodChangeTimeline&) override;
683 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800684 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
ramindani12bfe6b2023-02-03 13:29:19 -0800685 void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) override;
Huihong Luo817ebb82023-12-13 12:54:24 -0800686 void onComposerHalHdcpLevelsChanged(hal::HWDisplayId, const HdcpLevels& levels) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700687
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700688 // ICompositor overrides:
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500689 void configure() override REQUIRES(kMainThreadContext);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400690 bool commit(PhysicalDisplayId pacesetterId, const scheduler::FrameTargets&) override
691 REQUIRES(kMainThreadContext);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500692 CompositeResultsPerDisplay composite(PhysicalDisplayId pacesetterId,
693 const scheduler::FrameTargeters&) override
694 REQUIRES(kMainThreadContext);
695
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700696 void sample() override;
697
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700698 // ISchedulerCallback overrides:
Dominik Laskowski66295432023-03-14 12:25:36 -0400699 void requestHardwareVsync(PhysicalDisplayId, bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400700 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800701 void kernelTimerChanged(bool expired) override;
Ady Abraham822ecbd2023-07-07 16:16:09 -0700702 void onChoreographerAttached() override;
ramindaniae645822024-01-11 10:57:29 -0800703 void onExpectedPresentTimePosted(TimePoint expectedPresentTime, ftl::NonNull<DisplayModePtr>,
704 Fps renderRate) override;
Ady Abraham14beed72024-05-15 17:16:45 -0700705 void onCommitNotComposited(PhysicalDisplayId pacesetterDisplayId) override
706 REQUIRES(kMainThreadContext);
Ady Abrahameba039c2024-07-10 17:45:29 -0700707 void vrrDisplayIdle(bool idle) override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700708
jimmyshiu4e211772023-06-15 15:18:38 +0000709 // ICEPowerCallback overrides:
710 void notifyCpuLoadUp() override;
711
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400712 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400713
ramindani32cf0602022-03-02 02:30:29 +0000714 // Get the controller and timeout that will help decide how the kernel idle timer will be
715 // configured and what value to use as the timeout.
716 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
Dominik Laskowski6e465152022-09-28 11:00:25 -0400717 getKernelIdleTimerProperties(PhysicalDisplayId) REQUIRES(mStateLock);
Dominik Laskowski43839672024-08-04 02:01:48 -0400718
Lloyd Pique30db6402023-06-26 18:56:51 +0000719 // Show spinner with refresh rate overlay
720 bool mRefreshRateOverlaySpinner = false;
721 // Show render rate with refresh rate overlay
722 bool mRefreshRateOverlayRenderRate = false;
723 // Show render rate overlay offseted to the middle of the screen (e.g. for circular displays)
724 bool mRefreshRateOverlayShowInMiddle = false;
Sally Qi147581b2023-06-27 11:55:34 -0700725 // Show hdr sdr ratio overlay
726 bool mHdrSdrRatioOverlay = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700727
Bart Sears2d7e7f82024-07-13 19:42:29 +0000728 void setDesiredMode(display::DisplayModeRequest&&) REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400729
Ady Abraham38027262023-10-17 16:58:25 -0700730 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId, Fps minFps,
731 Fps maxFps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400732
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400733 void initiateDisplayModeChanges() REQUIRES(kMainThreadContext) REQUIRES(mStateLock);
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400734 void finalizeDisplayModeChange(PhysicalDisplayId) REQUIRES(kMainThreadContext)
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400735 REQUIRES(mStateLock);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400736
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400737 void dropModeRequest(PhysicalDisplayId) REQUIRES(kMainThreadContext);
738 void applyActiveMode(PhysicalDisplayId) REQUIRES(kMainThreadContext);
Dominik Laskowski59746512023-11-19 09:30:24 -0500739
Marin Shalamanov5801c942020-12-17 17:00:13 +0100740 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700741 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700742 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800743
Dominik Laskowskif2595442022-08-29 13:51:57 -0700744 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
745 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800746 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400747 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700748
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400749 status_t setDesiredDisplayModeSpecsInternal(
750 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700751 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800752
Dominik Laskowski3f726402022-11-21 17:21:22 -0500753 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
754 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
Dominik Laskowski1746afd2024-04-10 19:21:37 -0400755 const scheduler::RefreshRateSelector&)
Dominik Laskowski3f726402022-11-21 17:21:22 -0500756 REQUIRES(mStateLock, kMainThreadContext);
757
Vishnu Nair878911f2024-03-27 22:20:24 -0700758 void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700759 void commitTransactionsLocked(uint32_t transactionFlags)
760 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700761 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800762
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000763 std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(
Vishnu Nair7be27602024-03-28 20:27:09 -0700764 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
765 REQUIRES(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000766 void moveSnapshotsFromCompositionArgs(compositionengine::CompositionRefreshArgs& refreshArgs,
Vishnu Nair7be27602024-03-28 20:27:09 -0700767 const std::vector<std::pair<Layer*, LayerFE*>>& layers)
768 REQUIRES(kMainThreadContext);
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700769 // Return true if we must composite this frame
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000770 bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000771 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nair7be27602024-03-28 20:27:09 -0700772 void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800773
Vishnu Nair7be27602024-03-28 20:27:09 -0700774 void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800775 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800776 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
Vishnu Nair7be27602024-03-28 20:27:09 -0700777 std::vector<gui::DisplayInfo>& outDisplayInfos)
778 REQUIRES(kMainThreadContext);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800779 void commitInputWindowCommands() REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -0700780 void updateCursorAsync() REQUIRES(kMainThreadContext);
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700781
Dominik Laskowski59db9562022-10-27 16:18:53 -0400782 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowski14956dc2023-02-22 13:43:57 -0500783
Peiyong Linf243e5e2020-08-22 17:40:59 -0700784 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700785 * Transactions
786 */
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000787 bool applyTransactionState(const FrameTimelineInfo& info,
788 std::vector<ResolvedComposerState>& state,
789 Vector<DisplayState>& displays, uint32_t flags,
790 const InputWindowCommands& inputWindowCommands,
791 const int64_t desiredPresentTime, bool isAutoTimestamp,
792 const std::vector<uint64_t>& uncacheBufferIds,
793 const int64_t postTime, bool hasListenerCallbacks,
794 const std::vector<ListenerCallbacks>& listenerCallbacks,
795 int originPid, int originUid, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700796 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700797 // Flush pending transactions that were presented after desiredPresentTime.
Vishnu Nair42ad3192023-01-24 19:17:59 -0800798 // For test only
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700799 bool flushTransactionQueues(VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800800
801 bool applyTransactions(std::vector<TransactionState>&, VsyncId) REQUIRES(kMainThreadContext);
Vishnu Nair878911f2024-03-27 22:20:24 -0700802 bool applyAndCommitDisplayTransactionStatesLocked(std::vector<TransactionState>& transactions)
803 REQUIRES(kMainThreadContext, mStateLock);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800804
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700805 // Returns true if there is at least one transaction that needs to be flushed
Vishnu Nair7be27602024-03-28 20:27:09 -0700806 bool transactionFlushNeeded() REQUIRES(kMainThreadContext);
807 void addTransactionReadyFilters() REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700808 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
809 const TransactionHandler::TransactionFlushState& flushState)
810 REQUIRES(kMainThreadContext);
811 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
812 const TransactionHandler::TransactionFlushState& flushState)
813 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800814
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000815 uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,
816 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000817 int64_t postTime, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700818 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700819 uint32_t getTransactionFlags() const;
820
Dominik Laskowski94000c42022-03-17 12:55:14 -0700821 // Sets the masked bits, and schedules a commit if needed.
822 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700823 const sp<IBinder>& applyToken = nullptr,
824 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700825
826 // Clears and returns the masked bits.
827 uint32_t clearTransactionFlags(uint32_t mask);
828
chaviw74d90ad2019-04-26 14:45:26 -0700829 void commitOffscreenLayers();
Dominik Laskowski94000c42022-03-17 12:55:14 -0700830
ramindani4d48f902021-09-20 21:07:45 +0000831 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000832 bool shouldLatchUnsignaled(const layer_state_t&, size_t numStates, bool firstTransaction) const;
Vishnu Nair42ad3192023-01-24 19:17:59 -0800833 bool applyTransactionsLocked(std::vector<TransactionState>& transactions, VsyncId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700834 REQUIRES(mStateLock, kMainThreadContext);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800835 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800836 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
837 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700838 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
839
Peiyong Linf243e5e2020-08-22 17:40:59 -0700840 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700841 * Layer management
842 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000843 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800844
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800845 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
846 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700847
Vishnu Nair84125ac2021-12-02 08:47:48 -0800848 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800849 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700850
Vishnu Nair84125ac2021-12-02 08:47:48 -0800851 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000852 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700853
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000854 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000855 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000856
Josh Gao194ff392022-09-08 16:19:29 -0700857 void markLayerPendingRemovalLocked(const sp<Layer>& layer) REQUIRES(mStateLock);
Mathias Agopiana4912602012-07-12 14:25:33 -0700858
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700859 // add a layer to SurfaceFlinger
Vishnu Nair1391de22023-03-05 19:56:14 -0800860 status_t addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Naircb8be502022-10-12 19:03:23 +0000861 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700862 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700863
Melody Hsu793f8362024-01-08 20:00:35 +0000864 // Creates a promise for a future release fence for a layer. This allows for
865 // the layer to keep track of when its buffer can be released.
866 void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
867
868 // Checks if a protected layer exists in a list of layers.
Melody Hsu8c42cf12024-06-05 00:07:03 +0000869 bool layersHasProtectedLayer(const std::vector<sp<LayerFE>>& layers) const;
870
871 using OutputCompositionState = compositionengine::impl::OutputCompositionState;
872
Vishnu Nair5a93ccb2024-06-26 00:38:32 +0000873 std::optional<OutputCompositionState> getSnapshotsFromMainThread(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000874 RenderAreaBuilderVariant& renderAreaBuilder,
875 GetLayerSnapshotsFunction getLayerSnapshotsFn, std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu82d524e2024-02-23 02:37:38 +0000876
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000877 void captureScreenCommon(RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
878 ui::Size bufferSize, ui::PixelFormat, bool allowProtected,
879 bool grayscale, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000880
Melody Hsu8c42cf12024-06-05 00:07:03 +0000881 std::optional<OutputCompositionState> getDisplayStateFromRenderAreaBuilder(
882 RenderAreaBuilderVariant& renderAreaBuilder) REQUIRES(kMainThreadContext);
Melody Hsu335ef3e2024-05-31 22:58:40 +0000883
Melody Hsu8c42cf12024-06-05 00:07:03 +0000884 // Legacy layer raw pointer is not safe to access outside the main thread.
885 // Creates a new vector consisting only of LayerFEs, which can be safely
886 // accessed outside the main thread.
887 std::vector<sp<LayerFE>> extractLayerFEs(
888 const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const;
Melody Hsu335ef3e2024-05-31 22:58:40 +0000889
Melody Hsu82d524e2024-02-23 02:37:38 +0000890 ftl::SharedFuture<FenceResult> captureScreenshot(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000891 const RenderAreaBuilderVariant& renderAreaBuilder,
892 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
893 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>& captureListener,
894 std::optional<OutputCompositionState>& displayState,
895 std::vector<sp<LayerFE>>& layerFEs);
896
897 ftl::SharedFuture<FenceResult> captureScreenshotLegacy(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000898 RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000899 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
Chavi Weingarten18fa7c62023-11-28 21:16:03 +0000900 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000901
Melody Hsu793f8362024-01-08 20:00:35 +0000902 ftl::SharedFuture<FenceResult> renderScreenImpl(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000903 std::unique_ptr<const RenderArea>,
Melody Hsu793f8362024-01-08 20:00:35 +0000904 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
905 bool grayscale, bool isProtected, ScreenCaptureResults&,
Melody Hsu8c42cf12024-06-05 00:07:03 +0000906 std::optional<OutputCompositionState>& displayState,
907 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers,
908 std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu793f8362024-01-08 20:00:35 +0000909
Romain Guy11d63f42017-07-20 12:47:14 -0700910 void readPersistentProperties();
911
rnleeed20fa42021-08-10 18:00:03 -0700912 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700913
Peiyong Linf243e5e2020-08-22 17:40:59 -0700914 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700915 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700916 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700917
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400918 // Called during boot and restart after system_server death, setting the stage for bootanimation
919 // before DisplayManager takes over.
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400920 void initializeDisplays() REQUIRES(kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700921
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700922 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
923 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700924 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700925 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700926
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700927 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski80872bd2022-11-15 11:34:33 -0500928 return mDisplays.get(displayToken)
929 .or_else(ftl::static_ref<sp<DisplayDevice>>([] { return nullptr; }))
930 .value();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700931 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700932
Ady Abraham690f4612021-07-01 23:24:03 -0700933 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
934 REQUIRES(mStateLock) {
935 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
936 }
937
938 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
939 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
940 return getDisplayDeviceLocked(token);
941 }
942 return nullptr;
943 }
944
Dominik Laskowski3c363242022-04-07 10:44:12 -0700945 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
946 // TODO(b/182939859): Replace tokens with IDs for display lookup.
947 return findDisplay([id](const auto& display) { return display.getId() == id; });
948 }
949
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500950 std::shared_ptr<compositionengine::Display> getCompositionDisplayLocked(DisplayId id) const
951 REQUIRES(mStateLock) {
952 if (const auto display = getDisplayDeviceLocked(id)) {
953 return display->getCompositionDisplay();
954 }
955 return nullptr;
956 }
957
Dominik Laskowskia0858db2024-07-23 16:45:11 -0400958 // Returns the primary display or (for foldables) the active display.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700959 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700960 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700961 }
962
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700963 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -0700964 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -0700965 }
966
Ady Abraham3efa3942021-06-24 19:01:25 -0700967 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700968 Mutex::Autolock lock(mStateLock);
969 return getDefaultDisplayDeviceLocked();
970 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200971
Dominik Laskowski6e465152022-09-28 11:00:25 -0400972 using DisplayDeviceAndSnapshot = std::pair<sp<DisplayDevice>, display::DisplaySnapshotRef>;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700973
974 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
975 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
976 return [this](const display::PhysicalDisplay& display) REQUIRES(
977 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
978 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
979 return std::make_pair(std::move(device), display.snapshotRef());
980 }
981
982 return {};
983 };
984 }
985
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700986 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
987 template <typename Predicate>
988 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
989 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
Dominik Laskowski3de67272023-08-09 13:15:31 -0400990 [&](const auto& pair)
991 REQUIRES(mStateLock) { return p(*pair.second); });
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700992
993 return it == mDisplays.end() ? nullptr : it->second;
994 }
995
Ady Abrahamed3290f2021-05-17 15:12:14 -0700996 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
997
Mathias Agopian87baae12012-07-31 12:38:26 -0700998 // mark a region of a layer stack dirty. this updates the dirty
999 // region of all screens presenting this layer stack.
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001000 void invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -07001001
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001002 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
1003 REQUIRES(mStateLock) {
1004 return {layerStack,
1005 PhysicalDisplayId::tryCast(displayId)
1006 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
1007 .transform(&display::PhysicalDisplay::isInternal)
1008 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -07001009 }
1010
Peiyong Linf243e5e2020-08-22 17:40:59 -07001011 /*
Mathias Agopian86303202012-07-24 22:46:10 -07001012 * H/W composer
1013 */
Marin Shalamanov6e840172020-12-14 22:13:28 +01001014 // The following thread safety rules apply when accessing HWComposer:
1015 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
1016 // acquire mStateLock.
1017 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -07001018 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +01001019 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -07001020 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -07001021
Peiyong Linf243e5e2020-08-22 17:40:59 -07001022 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001023 * Compositing
1024 */
Leon Scroggins III5b581492023-10-31 14:29:41 -04001025 void onCompositionPresented(PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters&,
1026 nsecs_t presentStartTime) REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -07001027
Peiyong Linf243e5e2020-08-22 17:40:59 -07001028 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -07001029 * Display management
1030 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001031 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
1032 REQUIRES(mStateLock);
1033
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001034 // TODO(b/241285876): Move to DisplayConfigurator.
1035 //
1036 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
1037 // commit display transactions.
1038 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
1039 EXCLUDES(mHotplugMutex);
1040
Dominik Laskowski6e465152022-09-28 11:00:25 -04001041 // Returns the active mode ID, or nullopt on hotplug failure.
1042 std::optional<DisplayModeId> processHotplugConnect(PhysicalDisplayId, hal::HWDisplayId,
1043 DisplayIdentificationInfo&&,
1044 const char* displayString)
1045 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb8267b2024-04-26 16:23:07 -04001046 void processHotplugDisconnect(PhysicalDisplayId, const char* displayString)
1047 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07001048
Lloyd Pique542307f2018-10-19 13:24:08 -07001049 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07001050 const wp<IBinder>& displayToken,
1051 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -07001052 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +01001053 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001054 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001055 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001056 void processDisplayRemoved(const wp<IBinder>& displayToken)
1057 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +01001058 void processDisplayChanged(const wp<IBinder>& displayToken,
1059 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001060 const DisplayDeviceState& drawingState)
1061 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001062
Peiyong Linf243e5e2020-08-22 17:40:59 -07001063 /*
Dominik Laskowskic2867142019-01-21 11:33:38 -08001064 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001065 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001066 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +02001067 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001068 return mPhysicalDisplays.get(displayId)
1069 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
Dominik Laskowski80872bd2022-11-15 11:34:33 -05001070 .or_else([] { return std::optional<sp<display::DisplayToken>>(nullptr); })
1071 .value();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001072 }
1073
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001074 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001075 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001076
Dominik Laskowski3c363242022-04-07 10:44:12 -07001077 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001078 //
Dominik Laskowski3c363242022-04-07 10:44:12 -07001079 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
1080 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
1081 // display because SF does not support disconnecting it, though in practice HWC may circumvent
1082 // this limitation.)
1083 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
1084 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001085 }
1086
Dominik Laskowski3c363242022-04-07 10:44:12 -07001087 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001088 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001089 }
1090
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001091 // Toggles use of HAL/GPU virtual displays.
1092 void enableHalVirtualDisplays(bool);
1093
1094 // Virtual display lifecycle for ID generation and HAL allocation.
Dominik Laskowski263eec42021-07-21 23:13:24 -07001095 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat) REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001096 void releaseVirtualDisplay(VirtualDisplayId);
1097
Dominik Laskowski3de67272023-08-09 13:15:31 -04001098 // Returns a display other than `mActiveDisplayId` that can be activated, if any.
1099 sp<DisplayDevice> getActivatableDisplay() const REQUIRES(mStateLock, kMainThreadContext);
1100
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001101 void onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
1102 const DisplayDevice& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001103 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001104
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001105 void onActiveDisplaySizeChanged(const DisplayDevice&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001106
Dominik Laskowskic2867142019-01-21 11:33:38 -08001107 /*
1108 * Debugging & dumpsys
1109 */
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001110 void dumpAll(const DumpArgs& args, const std::string& compositionLayers,
1111 std::string& result) const EXCLUDES(mStateLock);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00001112 void dumpHwcLayersMinidump(std::string& result) const REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001113
1114 void appendSfConfigString(std::string& result) const;
Vishnu Nair7be27602024-03-28 20:27:09 -07001115 void listLayers(std::string& result) const REQUIRES(kMainThreadContext);
1116 void dumpStats(const DumpArgs& args, std::string& result) const
1117 REQUIRES(mStateLock, kMainThreadContext);
1118 void clearStats(const DumpArgs& args, std::string& result) REQUIRES(kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001119 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001120 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001121 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001122
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001123 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1124 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1125 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001126
1127 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1128 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001129 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001130 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001131 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
John Reck2a3d29d2023-08-17 17:45:01 -04001132 void dumpHdrInfo(std::string& result) const REQUIRES(mStateLock);
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001133 void dumpFrontEnd(std::string& result) REQUIRES(kMainThreadContext);
1134 void dumpVisibleFrontEnd(std::string& result) REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001135
Vishnu Nair7be27602024-03-28 20:27:09 -07001136 perfetto::protos::LayersProto dumpDrawingStateProto(uint32_t traceFlags) const
1137 REQUIRES(kMainThreadContext);
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001138 void dumpOffscreenLayersProto(perfetto::protos::LayersProto& layersProto,
Vishnu Nair516228f2024-07-11 23:03:02 +00001139 uint32_t traceFlags = LayerTracing::TRACE_ALL) const
1140 REQUIRES(kMainThreadContext);
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001141 google::protobuf::RepeatedPtrField<perfetto::protos::DisplayProto> dumpDisplayProto() const;
Kean Mariotti639b54f2023-04-20 12:06:29 +00001142 void doActiveLayersTracingIfNeeded(bool isCompositionComputed, bool visibleRegionDirty,
1143 TimePoint, VsyncId) REQUIRES(kMainThreadContext);
1144 perfetto::protos::LayersSnapshotProto takeLayersSnapshotProto(uint32_t flags, TimePoint,
1145 VsyncId, bool visibleRegionDirty)
Vishnu Nair81750622023-03-08 15:02:06 -08001146 REQUIRES(kMainThreadContext);
chaviw0a398992021-08-13 10:13:01 -05001147
Alec Mouri6b9e9912020-01-21 10:50:24 -08001148 // Dumps state from HW Composer
1149 void dumpHwc(std::string& result) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001150 perfetto::protos::LayersProto dumpProtoFromMainThread(
1151 uint32_t traceFlags = LayerTracing::TRACE_ALL) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001152 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001153
Dominik Laskowskic2867142019-01-21 11:33:38 -08001154 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1155
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001156 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001157
1158 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1159 return doDump(fd, args, asProto);
1160 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001161
chaviw17ac24b2021-01-28 18:50:05 -08001162 static mat4 calculateColorMatrix(float saturation);
1163
Chia-I Wu28f320b2018-05-03 11:02:56 -07001164 void updateColorMatrixLocked();
1165
Peiyong Linf243e5e2020-08-22 17:40:59 -07001166 // Verify that transaction is being called by an approved process:
1167 // either AID_GRAPHICS or AID_SYSTEM.
1168 status_t CheckTransactCodeCredentials(uint32_t code);
1169
Ady Abrahame46243a2021-02-23 19:33:49 -08001170 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001171
Peiyong Linf243e5e2020-08-22 17:40:59 -07001172 /*
1173 * Generic Layer Metadata
1174 */
1175 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1176
Lloyd Pique30db6402023-06-26 18:56:51 +00001177 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1178 std::chrono::nanoseconds presentLatency);
Ady Abraham899dcdb2021-06-15 16:56:21 -07001179 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001180
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00001181 bool isHdrLayer(const frontend::LayerSnapshot& snapshot) const;
John Reck49d9ad32022-02-23 19:03:31 -05001182
ramindani06e518e2022-03-14 18:47:53 +00001183 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1184 REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001185 void traverseLegacyLayers(const LayerVector::Visitor& visitor) const
1186 REQUIRES(kMainThreadContext);
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001187
1188 void initBootProperties();
Vishnu Nair8c5b7002023-08-17 21:03:57 -07001189 void initTransactionTraceWriter();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001190
Lloyd Pique30db6402023-06-26 18:56:51 +00001191 surfaceflinger::Factory& mFactory;
1192 pid_t mPid;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001193
1194 // TODO: b/328459745 - Encapsulate in a SystemProperties object.
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001195 utils::OnceFuture mInitBootPropsFuture;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001196
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001197 utils::OnceFuture mRenderEnginePrimeCacheFuture;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001198
Leon Scroggins III67388622023-02-06 20:36:20 -05001199 // mStateLock has conventions related to the current thread, because only
1200 // the main thread should modify variables protected by mStateLock.
1201 // - read access from a non-main thread must lock mStateLock, since the main
1202 // thread may modify these variables.
1203 // - write access from a non-main thread is not permitted.
1204 // - read access from the main thread can use an ftl::FakeGuard, since other
1205 // threads must not modify these variables.
1206 // - write access from the main thread must lock mStateLock, since another
1207 // thread may be reading these variables.
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001208 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001209 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001210 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001211 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001212 SortedVector<sp<Layer>> mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001213
Brian Lindahl439afad2022-11-14 11:16:55 -07001214 // Buffers that have been discarded by clients and need to be evicted from per-layer caches so
1215 // the graphics memory can be immediately freed.
1216 std::vector<uint64_t> mBufferIdsToUncache;
1217
Chia-I Wu28f320b2018-05-03 11:02:56 -07001218 // global color transform states
1219 Daltonizer mDaltonizer;
1220 float mGlobalSaturationFactor = 1.0f;
1221 mat4 mClientColorMatrix;
1222
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001223 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001224 bool mLayersRemoved = false;
1225 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001226
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001227 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001228 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001229
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001230 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001231 const nsecs_t mBootTime = systemTime();
Lloyd Pique30db6402023-06-26 18:56:51 +00001232 bool mIsUserBuild = true;
Dominik Laskowskie62606d2024-02-22 11:42:13 -05001233 bool mHasReliablePresentFences = false;
Mathias Agopian3094df32012-06-18 18:06:45 -07001234
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001235 // Can only accessed from the main thread, these members
1236 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001237 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001238 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001239
John Reck68796592023-01-25 13:47:12 -05001240 bool mHdrLayerInfoChanged = false;
1241
Robert Carr167bdde2021-07-28 11:26:51 -07001242 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1243 // scene hasn't changed
1244 bool mAddingHDRLayerInfoListener = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00001245 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001246
Robert Carre450fb52021-06-11 13:21:09 -07001247 // Set during transaction application stage to track if the input info or children
1248 // for a layer has changed.
1249 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001250 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001251 bool mSomeChildrenChanged;
Robert Carrb552ff52021-06-11 13:35:54 -07001252 bool mForceTransactionDisplayChange = false;
Ady Abraham822ecbd2023-07-07 16:16:09 -07001253 bool mUpdateAttachedChoreographer = false;
Robert Carre450fb52021-06-11 13:21:09 -07001254
Vishnu Nair39a74a92024-07-29 19:01:50 +00001255 struct LayerIntHash {
1256 size_t operator()(const std::pair<sp<Layer>, gui::GameMode>& k) const {
1257 return std::hash<Layer*>()(k.first.get()) ^
1258 std::hash<int32_t>()(static_cast<int32_t>(k.second));
1259 }
1260 };
1261
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001262 // TODO(b/238781169) validate these on composition
Alec Mouri5c9c9602020-09-01 15:10:40 -07001263 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001264 // latched.
Vishnu Nair39a74a92024-07-29 19:01:50 +00001265 std::unordered_set<std::pair<sp<Layer>, gui::GameMode>, LayerIntHash> mLayersWithQueuedFrames;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001266 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;
Vishnu Nair6f209e22023-08-04 16:33:23 +00001267 std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;
1268
Vishnu Nair802ac4f2023-05-10 13:55:22 -07001269 // Sorted list of layers that were composed during previous frame. This is used to
1270 // avoid an expensive traversal of the layer hierarchy when there are no
1271 // visible region changes. Because this is a list of strong pointers, this will
1272 // extend the life of the layer but this list is only updated in the main thread.
1273 std::vector<sp<Layer>> mPreviouslyComposedLayers;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001274
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001275 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001276
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001277 struct HotplugEvent {
1278 hal::HWDisplayId hwcDisplayId;
1279 hal::Connection connection = hal::Connection::INVALID;
1280 };
1281
Huihong Luo9ebb7a72023-06-27 17:01:50 -07001282 bool mIsHdcpViaNegVsync = false;
Huihong Luoaac3a772023-09-19 20:51:59 -07001283 bool mIsHotplugErrViaNegVsync = false;
1284
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001285 std::mutex mHotplugMutex;
1286 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001287
Dominik Laskowskieb627312022-04-07 09:13:16 -07001288 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1289 // never removed, so take precedence over external and virtual displays.
1290 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001291 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001292 ui::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001293
1294 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001295
Dominik Laskowskia0858db2024-07-23 16:45:11 -04001296 // The inner or outer display for foldables, while unfolded or folded, respectively.
Dominik Laskowski5c989f52024-04-11 13:57:14 -04001297 std::atomic<PhysicalDisplayId> mActiveDisplayId;
Dominik Laskowskie591b552022-09-09 10:44:56 -07001298
Dominik Laskowski6e465152022-09-28 11:00:25 -04001299 display::DisplayModeController mDisplayModeController;
1300
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001301 struct {
1302 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1303 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1304 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001305
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001306 std::atomic_uint mDebugFlashDelay = 0;
1307 std::atomic_bool mDebugDisableHWC = false;
1308 std::atomic_bool mDebugDisableTransformHint = false;
1309 std::atomic<nsecs_t> mDebugInTransaction = 0;
1310 std::atomic_bool mForceFullDamage = false;
1311
Lloyd Pique30db6402023-06-26 18:56:51 +00001312 bool mLayerCachingEnabled = false;
1313 bool mBackpressureGpuComposition = false;
1314
Vishnu Nair81750622023-03-08 15:02:06 -08001315 LayerTracing mLayerTracing;
Dominik Laskowski46471e62022-01-14 15:34:03 -08001316 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001317
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001318 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001319 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001320 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001321
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001322 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001323
Lloyd Pique30db6402023-06-26 18:56:51 +00001324 // If blurs should be enabled on this device.
1325 bool mSupportsBlur = false;
1326
Robert Carr9a803c32021-01-14 16:57:58 -08001327 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001328
chaviweadf0d42019-08-12 13:28:29 -07001329 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001330
Steven Morelanda904bb92019-07-02 17:37:23 -07001331 // to linkToDeath
1332 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001333 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1334 // different threads without a lock and could trigger unsynchronized writes to
1335 // to mWindowManager or mInputFlinger
1336 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001337
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001338 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001339
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001340 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001341
Peiyong Lina3ea5592019-02-10 14:45:00 -08001342 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1343 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1344 // 2. be one of the supported color modes returned by hardware composer, otherwise
1345 // it will not be respected.
1346 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1347 // is not set to 1.
1348 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1349 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1350
Lloyd Pique30db6402023-06-26 18:56:51 +00001351 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1352 // If false, wide color modes are filtered out for all internal displays.
1353 bool mSupportsWideColor = false;
Dominik Laskowski788945b2022-08-30 12:10:56 -07001354
Lloyd Pique30db6402023-06-26 18:56:51 +00001355 ui::Dataspace mDefaultCompositionDataspace;
1356 ui::Dataspace mWideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001357
Patrick Williams0a525a42022-10-26 20:20:50 +00001358 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Chavi Weingarten076acac2023-01-19 17:20:43 +00001359 std::atomic<int> mNumTrustedPresentationListeners = 0;
1360
Lloyd Pique70d91362018-10-18 16:02:55 -07001361 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001362
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05001363 CompositionCoveragePerDisplay mCompositionCoverage;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001364
Garfield Tan9c9c1912021-07-19 12:02:16 -07001365 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1366 // any mutex.
1367 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001368
Lloyd Pique30db6402023-06-26 18:56:51 +00001369 const std::string mHwcServiceName;
1370
Dominik Laskowski068173d2021-08-11 17:22:59 -07001371 std::unique_ptr<scheduler::Scheduler> mScheduler;
Robert Carr720e5062018-07-30 17:45:14 -07001372
Dominik Laskowski80c77272022-07-08 12:47:29 -07001373 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001374
Lloyd Pique30db6402023-06-26 18:56:51 +00001375 bool mLumaSampling = true;
Kevin DuBois413287f2019-02-25 08:46:47 -08001376 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001377 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001378 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Lloyd Pique30db6402023-06-26 18:56:51 +00001379 ui::DisplayPrimaries mInternalDisplayPrimaries;
1380
1381 const float mEmulatedDisplayDensity;
1382 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001383
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001384 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001385 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001386 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001387
Xiang Wang839fe5b2022-04-04 17:39:38 +00001388 std::unique_ptr<Hwc2::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001389
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001390 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001391
Sally Qi147581b2023-06-27 11:55:34 -07001392 void enableHdrSdrRatioOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
1393
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001394 // Flag used to set override desired display mode from backdoor
1395 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001396
1397 // A set of layers that have no parent so they are not drawn on screen.
1398 // Should only be accessed by the main thread.
1399 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1400 // be any issues with a raw pointer referencing an invalid object.
1401 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001402
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001403 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001404
1405 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1406 GUARDED_BY(mStateLock);
John Reck68796592023-01-25 13:47:12 -05001407
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001408 mutable std::mutex mCreatedLayersLock;
arthurhungdba591c2021-02-08 17:28:49 +08001409
1410 // A temporay pool that store the created layers and will be added to current state in main
1411 // thread.
Vishnu Nair0fc7af52022-01-13 08:11:34 -08001412 std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001413 void handleLayerCreatedLocked(const LayerCreatedState&, VsyncId) REQUIRES(mStateLock);
arthurhungdba591c2021-02-08 17:28:49 +08001414
Ady Abraham1273ac12021-08-26 17:31:53 -07001415 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001416
Leon Scroggins III85d4b222023-05-09 13:58:18 -04001417 // Must only be accessed on the main thread.
1418 // TODO (b/259407931): Remove.
1419 static ui::Transform::RotationFlags sActiveDisplayRotationFlags;
1420
Ady Abraham1b11bc62021-06-03 19:51:19 -07001421 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001422 return hasDisplay(
1423 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001424 }
Sally Qi147581b2023-06-27 11:55:34 -07001425 bool isHdrSdrRatioOverlayEnabled() const REQUIRES(mStateLock) {
1426 return hasDisplay(
1427 [](const auto& display) { return display.isHdrSdrRatioOverlayEnabled(); });
1428 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001429 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00001430 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1431 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
1432 snapshotFilterFn);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001433 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Ajinkya Chalke02844632023-03-01 12:10:14 +00001434 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1435 std::unordered_set<uint32_t> excludeLayerIds);
1436 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001437 uint32_t rootLayerId, uint32_t uid, std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07001438 bool childrenOnly, const std::optional<FloatRect>& optionalParentCrop);
Ady Abraham1b11bc62021-06-03 19:51:19 -07001439
chaviw60c9d3e2021-06-04 12:52:17 -05001440 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001441
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001442 // returns the framerate of the layer with the given sequence ID
1443 float getLayerFramerate(nsecs_t now, int32_t id) const {
1444 return mScheduler->getLayerFramerate(now, id);
1445 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001446
Matt Buckley50c44062022-01-17 20:48:10 +00001447 bool mPowerHintSessionEnabled;
Robert Horvathdce110a2022-09-16 11:08:47 +02001448 // Whether a display should be turned on when initialized
1449 bool mSkipPowerOnForQuiescent;
Lloyd Pique30db6402023-06-26 18:56:51 +00001450
Vishnu Nair7be27602024-03-28 20:27:09 -07001451 frontend::LayerLifecycleManager mLayerLifecycleManager GUARDED_BY(kMainThreadContext);
1452 frontend::LayerHierarchyBuilder mLayerHierarchyBuilder GUARDED_BY(kMainThreadContext);
1453 frontend::LayerSnapshotBuilder mLayerSnapshotBuilder GUARDED_BY(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001454
Vishnu Nair7be27602024-03-28 20:27:09 -07001455 std::vector<std::pair<uint32_t, std::string>> mDestroyedHandles GUARDED_BY(mCreatedLayersLock);
1456 std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers
1457 GUARDED_BY(mCreatedLayersLock);
1458 std::vector<LayerCreationArgs> mNewLayerArgs GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001459 // These classes do not store any client state but help with managing transaction callbacks
1460 // and stats.
Vishnu Nair7be27602024-03-28 20:27:09 -07001461 std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers GUARDED_BY(kMainThreadContext);
Ady Abrahame9ebce02022-02-03 12:05:06 -08001462
Vishnu Nair7be27602024-03-28 20:27:09 -07001463 TransactionHandler mTransactionHandler GUARDED_BY(kMainThreadContext);
1464 ui::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos
1465 GUARDED_BY(kMainThreadContext);
1466 bool mFrontEndDisplayInfosChanged GUARDED_BY(kMainThreadContext) = false;
Patrick Williams1caf3b72023-03-31 10:59:10 -05001467
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05001468 // WindowInfo ids visible during the last commit.
Vishnu Nair7be27602024-03-28 20:27:09 -07001469 std::unordered_set<int32_t> mVisibleWindowIds GUARDED_BY(kMainThreadContext);
Brian Johnson51d8d5d2023-07-28 10:18:47 -07001470
1471 // Mirroring
1472 // Map of displayid to mirrorRoot
1473 ftl::SmallMap<int64_t, sp<SurfaceControl>, 3> mMirrorMapForDebug;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001474
ramindanic67d22c2023-11-28 14:58:47 -08001475 // NotifyExpectedPresentHint
ramindaniae645822024-01-11 10:57:29 -08001476 enum class NotifyExpectedPresentHintStatus {
1477 // Represents that framework can start sending hint if required.
1478 Start,
1479 // Represents that the hint is already sent.
1480 Sent,
1481 // Represents that the hint will be scheduled with a new frame.
1482 ScheduleOnPresent,
1483 // Represents that a hint will be sent instantly by scheduling on the main thread.
1484 ScheduleOnTx
1485 };
ramindanic67d22c2023-11-28 14:58:47 -08001486 struct NotifyExpectedPresentData {
ramindaniae645822024-01-11 10:57:29 -08001487 TimePoint lastExpectedPresentTimestamp{};
ramindanic67d22c2023-11-28 14:58:47 -08001488 Fps lastFrameInterval{};
ramindaniae645822024-01-11 10:57:29 -08001489 // hintStatus is read and write from multiple threads such as
1490 // main thread, EventThread. And is atomic for that reason.
1491 std::atomic<NotifyExpectedPresentHintStatus> hintStatus =
1492 NotifyExpectedPresentHintStatus::Start;
ramindanic67d22c2023-11-28 14:58:47 -08001493 };
1494 std::unordered_map<PhysicalDisplayId, NotifyExpectedPresentData> mNotifyExpectedPresentMap;
ramindaniae645822024-01-11 10:57:29 -08001495 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) override
1496 REQUIRES(kMainThreadContext);
ramindani32a88b12024-01-31 18:45:30 -08001497 void scheduleNotifyExpectedPresentHint(PhysicalDisplayId displayId,
1498 VsyncId vsyncId = VsyncId{
1499 FrameTimelineInfo::INVALID_VSYNC_ID});
ramindanic67d22c2023-11-28 14:58:47 -08001500 void notifyExpectedPresentIfRequired(PhysicalDisplayId, Period vsyncPeriod,
1501 TimePoint expectedPresentTime, Fps frameInterval,
1502 std::optional<Period> timeoutOpt);
1503
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001504 void sfdo_enableRefreshRateOverlay(bool active);
1505 void sfdo_setDebugFlash(int delay);
1506 void sfdo_scheduleComposite();
1507 void sfdo_scheduleCommit();
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001508 void sfdo_forceClientComposition(bool enabled);
Huihong Luof5029222021-12-16 14:33:46 -08001509};
1510
1511class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1512public:
Alan Dingfc6eab52024-05-02 18:28:45 -07001513 explicit SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001514
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001515 binder::Status bootFinished() override;
1516 binder::Status createDisplayEventConnection(
1517 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08001518 const sp<IBinder>& layerHandle,
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001519 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001520 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Alan Dingd53801c2024-05-08 16:45:29 -07001521 binder::Status createVirtualDisplay(const std::string& displayName, bool isSecure,
1522 const std::string& uniqueId, float requestedRefreshRate,
1523 sp<IBinder>* outDisplay) override;
1524 binder::Status destroyVirtualDisplay(const sp<IBinder>& displayToken) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001525 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001526 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001527 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001528 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001529 binder::Status getDisplayStats(const sp<IBinder>& display,
1530 gui::DisplayStatInfo* outStatInfo) override;
1531 binder::Status getDisplayState(const sp<IBinder>& display,
1532 gui::DisplayState* outState) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001533 binder::Status getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08001534 gui::StaticDisplayInfo* outInfo) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001535 binder::Status getDynamicDisplayInfoFromId(int64_t displayId,
1536 gui::DynamicDisplayInfo* outInfo) override;
1537 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
1538 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001539 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1540 gui::DisplayPrimaries* outPrimaries) override;
1541 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1542 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001543 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1544 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001545 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001546 binder::Status getHdrConversionCapabilities(
1547 std::vector<gui::HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +01001548 binder::Status setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
1549 int32_t*) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001550 binder::Status getHdrOutputConversionSupport(bool* outSupport) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001551 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1552 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001553 binder::Status captureDisplay(const DisplayCaptureArgs&,
1554 const sp<IScreenCaptureListener>&) override;
John Reck7e4c4872023-11-14 18:31:03 -05001555 binder::Status captureDisplayById(int64_t, const CaptureArgs&,
1556 const sp<IScreenCaptureListener>&) override;
Huihong Luof5029222021-12-16 14:33:46 -08001557 binder::Status captureLayers(const LayerCaptureArgs&,
1558 const sp<IScreenCaptureListener>&) override;
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00001559 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults* results);
Dominik Laskowski66296b22022-07-12 08:20:36 -07001560
1561 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001562 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1563 return binder::Status::ok();
1564 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001565 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001566 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001567 }
1568
Huihong Luo05539a12022-02-23 10:29:40 -08001569 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1570 const std::vector<int32_t>& hdrTypes) override;
1571 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001572 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1573 binder::Status getDisplayedContentSamplingAttributes(
1574 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1575 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1576 int8_t componentMask,
1577 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001578 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1579 int64_t timestamp,
1580 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001581 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001582 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1583 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001584 binder::Status addRegionSamplingListener(
1585 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1586 const sp<gui::IRegionSamplingListener>& listener) override;
1587 binder::Status removeRegionSamplingListener(
1588 const sp<gui::IRegionSamplingListener>& listener) override;
1589 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1590 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1591 binder::Status addTunnelModeEnabledListener(
1592 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1593 binder::Status removeTunnelModeEnabledListener(
1594 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001595 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1596 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001597 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1598 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001599 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1600 bool* outSupport) override;
1601 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1602 const gui::DisplayBrightness& brightness) override;
1603 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1604 const sp<gui::IHdrLayerInfoListener>& listener) override;
1605 binder::Status removeHdrLayerInfoListener(
1606 const sp<IBinder>& displayToken,
1607 const sp<gui::IHdrLayerInfoListener>& listener) override;
John Reck68796592023-01-25 13:47:12 -05001608
Huihong Luo37396db2022-02-15 10:43:00 -08001609 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001610 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1611 const gui::Color& spotColor, float lightPosY,
1612 float lightPosZ, float lightRadius) override;
1613 binder::Status getDisplayDecorationSupport(
1614 const sp<IBinder>& displayToken,
1615 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
Andy Yu8c2703d2023-11-03 11:22:46 -07001616 binder::Status setGameModeFrameRateOverride(int32_t uid, float frameRate) override;
1617 binder::Status setGameDefaultFrameRateOverride(int32_t uid, float frameRate) override;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001618 binder::Status enableRefreshRateOverlay(bool active) override;
1619 binder::Status setDebugFlash(int delay) override;
1620 binder::Status scheduleComposite() override;
1621 binder::Status scheduleCommit() override;
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001622 binder::Status forceClientComposition(bool enabled) override;
Tony Huangf3621102023-09-04 17:14:22 +08001623 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00001624 const std::vector<float>& thresholds) override;
Tony Huangf3621102023-09-04 17:14:22 +08001625 binder::Status setSmallAreaDetectionThreshold(int32_t appId, float threshold) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001626 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1627 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
Patrick Williamsacd22582023-07-12 13:47:28 -05001628 binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
1629 gui::WindowInfosListenerInfo* outInfo) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001630 binder::Status removeWindowInfosListener(
1631 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Ady Abraham07d03c42023-09-27 19:15:08 -07001632 binder::Status getStalledTransactionInfo(
1633 int pid, std::optional<gui::StalledTransactionInfo>* outInfo) override;
1634 binder::Status getSchedulingPolicy(gui::SchedulingPolicy* outPolicy) override;
Wenhui Yangeafc18a2024-05-14 17:15:52 +00001635 binder::Status notifyShutdown() override;
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001636 binder::Status addJankListener(const sp<IBinder>& layer,
1637 const sp<gui::IJankListener>& listener) override;
1638 binder::Status flushJankData(int32_t layerId) override;
1639 binder::Status removeJankListener(int32_t layerId, const sp<gui::IJankListener>& listener,
1640 int64_t afterVsync) override;
Huihong Luof5029222021-12-16 14:33:46 -08001641
1642private:
Huihong Luo07e72362022-02-14 14:26:04 -08001643 static const constexpr bool kUsePermissionCache = true;
1644 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001645 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001646 status_t checkReadFrameBufferPermission();
Sally Qi6bb12822022-10-05 11:42:30 -07001647 static void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
1648 gui::DynamicDisplayInfo*& outInfo);
Huihong Luo07e72362022-02-14 14:26:04 -08001649
1650private:
Alan Dingfc6eab52024-05-02 18:28:45 -07001651 const sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001652};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001653
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001654} // namespace android