blob: ad3f24f7e1c617b34f1fbada56b107d3dccc3f33 [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 Luo791bef92023-09-19 21:18:45 -0700138using ::aidl::android::hardware::graphics::common::DisplayHotplugEvent;
ramindani12bfe6b2023-02-03 13:29:19 -0800139using ::aidl::android::hardware::graphics::composer3::RefreshRateChangedDebugData;
Vishnu Nairaf6d2972022-11-18 06:26:38 +0000140using frontend::TransactionHandler;
Huihong Luof5029222021-12-16 14:33:46 -0800141using gui::CaptureArgs;
142using gui::DisplayCaptureArgs;
Huihong Luoecc1f902021-11-20 11:55:05 -0800143using gui::IRegionSamplingListener;
Huihong Luof5029222021-12-16 14:33:46 -0800144using gui::LayerCaptureArgs;
chaviw0ef7caa2021-01-05 11:04:50 -0800145using gui::ScreenCaptureResults;
146
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700147namespace frametimeline {
148class FrameTimeline;
149}
150
Chris Ye0783e992020-06-02 21:34:49 -0700151namespace os {
152 class IInputFlinger;
153}
154
Lloyd Pique542307f2018-10-19 13:24:08 -0700155namespace compositionengine {
156class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800157class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800158
159struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700160} // namespace compositionengine
161
Peiyong Lin833074a2018-08-28 11:53:54 -0700162namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800163class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700164} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700165
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800166enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700167 eTransactionNeeded = 0x01,
168 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700169 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700170 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700171 eTransactionFlushNeeded = 0x10,
Patrick Williamsaf06b792023-02-16 17:46:22 -0600172 eInputInfoUpdateNeeded = 0x20,
173 eTransactionMask = 0x3f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800174};
175
Ady Abraham9dada822022-02-03 10:26:59 -0800176// Latch Unsignaled buffer behaviours
177enum class LatchUnsignaledConfig {
178 // All buffers are latched signaled.
179 Disabled,
180
181 // Latch unsignaled is permitted when a single layer is updated in a frame,
182 // and the update includes just a buffer update (i.e. no sync transactions
183 // or geometry changes).
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000184 // Latch unsignaled is also only permitted when a single transaction is ready
185 // to be applied. If we pass an unsignaled fence to HWC, HWC might miss presenting
186 // the frame if the fence does not fire in time. If we apply another transaction,
187 // we may penalize the other transaction unfairly.
Ady Abraham9dada822022-02-03 10:26:59 -0800188 AutoSingleLayer,
189
190 // All buffers are latched unsignaled. This behaviour is discouraged as it
191 // can break sync transactions, stall the display and cause undesired side effects.
Vishnu Nairf01a6f12023-04-03 22:34:17 +0000192 // This is equivalent to ignoring the acquire fence when applying transactions.
Ady Abraham9dada822022-02-03 10:26:59 -0800193 Always,
194};
ramindani4d48f902021-09-20 21:07:45 +0000195
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000196struct DisplayRenderAreaBuilder;
197struct LayerRenderAreaBuilder;
198
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800199using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800200
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700201class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700202 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700203 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800204 private HWC2::ComposerCallback,
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700205 private ICompositor,
jimmyshiu4e211772023-06-15 15:18:38 +0000206 private scheduler::ISchedulerCallback,
ramindaniae645822024-01-11 10:57:29 -0800207 private compositionengine::ICEPowerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800208public:
Lloyd Pique30db6402023-06-26 18:56:51 +0000209 struct SkipInitializationTag {};
210
211 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
212 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700213
214 // set main thread scheduling policy
215 static status_t setSchedFifo(bool enabled) ANDROID_API;
216
Wei Wang23aa5a62021-06-04 15:56:57 -0700217 // set main thread scheduling attributes
218 static status_t setSchedAttr(bool enabled);
219
Peiyong Linf243e5e2020-08-22 17:40:59 -0700220 static char const* getServiceName() ANDROID_API { return "SurfaceFlinger"; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800221
Lloyd Pique30db6402023-06-26 18:56:51 +0000222 // If fences from sync Framework are supported.
223 static bool hasSyncFramework;
224
225 // The offset in nanoseconds to use when VsyncController timestamps present fence
226 // signaling time.
227 static int64_t dispSyncPresentTimeOffset;
228
229 // Some hardware can do RGB->YUV conversion more efficiently in hardware
230 // controlled by HWC than in hardware controlled by the video encoder.
231 // This instruct VirtualDisplaySurface to use HWC for such conversion on
232 // GL composition.
233 static bool useHwcForRgbToYuv;
234
235 // Controls the number of buffers SurfaceFlinger will allocate for use in
236 // FramebufferSurface
237 static int64_t maxFrameBufferAcquiredBuffers;
238
239 // Controls the minimum acquired buffers SurfaceFlinger will suggest via
240 // ISurfaceComposer.getMaxAcquiredBufferCount().
241 static int64_t minAcquiredBuffers;
242
243 // Controls the maximum width and height in pixels that the graphics pipeline can support for
244 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
245 static uint32_t maxGraphicsWidth;
246 static uint32_t maxGraphicsHeight;
247
Lloyd Pique30db6402023-06-26 18:56:51 +0000248 static bool useContextPriority;
249
250 // The data space and pixel format that SurfaceFlinger expects hardware composer
251 // to composite efficiently. Meaning under most scenarios, hardware composer
252 // will accept layers with the data space and pixel format.
253 static ui::Dataspace defaultCompositionDataspace;
254 static ui::PixelFormat defaultCompositionPixelFormat;
255
256 // The data space and pixel format that SurfaceFlinger expects hardware composer
257 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
258 // hardware composer will accept layers with the data space and pixel format.
259 static ui::Dataspace wideColorGamutCompositionDataspace;
260 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
261
262 static constexpr SkipInitializationTag SkipInitialization;
263
ramindani4d48f902021-09-20 21:07:45 +0000264 static LatchUnsignaledConfig enableLatchUnsignaledConfig;
Huihong Luof3441822021-06-16 15:41:07 -0700265
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700266 // must be called before clients can connect
267 void init() ANDROID_API;
268
269 // starts SurfaceFlinger main loop in the current thread
270 void run() ANDROID_API;
271
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700272 // Indicates frame activity, i.e. whether commit and/or composite is taking place.
273 enum class FrameHint { kNone, kActive };
274
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700275 // Schedule commit of transactions on the main thread ahead of the next VSYNC.
Ady Abraham9953e062024-07-24 22:56:22 -0700276 void scheduleCommit(FrameHint, Duration workDurationSlack = Duration::fromNs(0));
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700277 // As above, but also force composite regardless if transactions were committed.
Dominik Laskowskidd5827a2022-03-17 12:44:23 -0700278 void scheduleComposite(FrameHint);
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700279 // As above, but also force dirty geometry to repaint.
280 void scheduleRepaint();
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700281 // Schedule sampling independently from commit or composite.
282 void scheduleSample();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800283
Lloyd Pique30db6402023-06-26 18:56:51 +0000284 surfaceflinger::Factory& getFactory() { return mFactory; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700285
Lloyd Pique70d91362018-10-18 16:02:55 -0700286 // The CompositionEngine encapsulates all composition related interfaces and actions.
287 compositionengine::CompositionEngine& getCompositionEngine() const;
288
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700289 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700290
Dominik Laskowski75848362019-11-11 17:57:20 -0800291 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700292 void onLayerDestroyed(Layer*);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700293 void onLayerUpdate();
Robert Carr2e102c92018-10-23 12:11:15 -0700294
Vishnu Nair07e2a482022-10-18 19:18:16 +0000295 // Called when all clients have released all their references to
296 // this layer. The layer may still be kept alive by its parents but
297 // the client can no longer modify this layer directly.
298 void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);
299
Robert Carr9a803c32021-01-14 16:57:58 -0800300 TransactionCallbackInvoker& getTransactionCallbackInvoker() {
301 return mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -0700302 }
303
Lloyd Pique30db6402023-06-26 18:56:51 +0000304 // If set, disables reusing client composition buffers. This can be set by
305 // debug.sf.disable_client_composition_cache
306 bool mDisableClientCompositionCache = false;
307
Alec Mouridea1ac52021-06-23 18:12:18 -0700308 // Disables expensive rendering for all displays
309 // This is scheduled on the main thread
310 void disableExpensiveRendering();
311
Vishnu Naira3140382022-02-24 14:07:11 -0800312 // If set, composition engine tries to predict the composition strategy provided by HWC
313 // based on the previous frame. If the strategy can be predicted, gpu composition will
314 // run parallel to the hwc validateDisplay call and re-run if the predition is incorrect.
315 bool mPredictCompositionStrategy = false;
316
Lloyd Pique30db6402023-06-26 18:56:51 +0000317 // If true, then any layer with a SMPTE 170M transfer function is decoded using the sRGB
318 // transfer instead. This is mainly to preserve legacy behavior, where implementations treated
319 // SMPTE 170M as sRGB prior to color management being implemented, and now implementations rely
320 // on this behavior to increase contrast for some media sources.
321 bool mTreat170mAsSrgb = false;
322
Alec Mouri9af38ba2023-08-16 22:41:14 +0000323 // If true, then screenshots with an enhanced render intent will dim in gamma space.
324 // The purpose is to ensure that screenshots appear correct during system animations for devices
325 // that require that dimming must occur in gamma space.
326 bool mDimInGammaSpaceForEnhancedScreenshots = false;
327
Lloyd Pique30db6402023-06-26 18:56:51 +0000328 // Allows to ignore physical orientation provided through hwc API in favour of
329 // 'ro.surface_flinger.primary_display_orientation'.
330 // TODO(b/246793311): Clean up a temporary property
331 bool mIgnoreHwcPhysicalDisplayOrientation = false;
332
Chavi Weingarten076acac2023-01-19 17:20:43 +0000333 void forceFutureUpdate(int delayInMs);
Vishnu Nair2f65e972023-04-04 16:36:28 +0000334 const DisplayDevice* getDisplayFromLayerStack(ui::LayerStack)
335 REQUIRES(mStateLock, kMainThreadContext);
Chavi Weingarten076acac2023-01-19 17:20:43 +0000336
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400337 // TODO (b/259407931): Remove.
338 // TODO (b/281857977): This should be annotated with REQUIRES(kMainThreadContext), but this
339 // would require thread safety annotations throughout the frontend (in particular Layer and
340 // LayerFE).
341 static ui::Transform::RotationFlags getActiveDisplayRotationFlags() {
342 return sActiveDisplayRotationFlags;
343 }
344
Peiyong Linf243e5e2020-08-22 17:40:59 -0700345protected:
346 // We're reference counted, never destroy SurfaceFlinger directly
347 virtual ~SurfaceFlinger();
348
Dominik Laskowski263eec42021-07-21 23:13:24 -0700349 virtual void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
350 REQUIRES(mStateLock);
351
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800352 virtual std::shared_ptr<renderengine::ExternalTexture> getExternalTextureFromBufferData(
Patrick Williamsf1e5df12022-10-17 21:37:42 +0000353 BufferData& bufferData, const char* layerName, uint64_t transactionId);
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800354
Dominik Laskowski263eec42021-07-21 23:13:24 -0700355 // Returns true if any display matches a `bool(const DisplayDevice&)` predicate.
356 template <typename Predicate>
357 bool hasDisplay(Predicate p) const REQUIRES(mStateLock) {
358 return static_cast<bool>(findDisplay(p));
359 }
360
chaviwba4320c2021-09-15 15:20:53 -0500361 bool exceedsMaxRenderTargetSize(uint32_t width, uint32_t height) const {
362 return width > mMaxRenderTargetSize || height > mMaxRenderTargetSize;
363 }
364
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700365private:
David Sodman0c69cad2017-08-21 12:12:51 -0700366 friend class BufferLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700367 friend class Client;
Alec Mouria9a68a62021-03-04 19:14:50 -0800368 friend class FpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +0200369 friend class TunnelModeEnabledReporter;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700370 friend class Layer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700371 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800372 friend class RegionSamplingThread;
Robert Carr22ceeaa2022-03-08 13:13:22 -0800373 friend class LayerRenderArea;
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700374 friend class SurfaceComposerAIDL;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000375 friend class DisplayRenderArea;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800376
Lloyd Piquef58625d2017-12-19 13:22:33 -0800377 // For unit tests
378 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700379 friend class TransactionApplicationTest;
Robert Carr3e2a2992021-06-11 13:42:55 -0700380 friend class TunnelModeEnabledReporterTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800381
Peiyong Linf243e5e2020-08-22 17:40:59 -0700382 using TransactionSchedule = scheduler::TransactionSchedule;
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000383 using GetLayerSnapshotsFunction = std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()>;
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000384 using RenderAreaBuilderVariant = std::variant<DisplayRenderAreaBuilder, LayerRenderAreaBuilder>;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700385 using DumpArgs = Vector<String16>;
386 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
387
Robert Carr2047fae2016-11-28 14:09:09 -0800388 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800389 public:
Vishnu Naira12c5c72024-08-28 15:42:17 -0700390 explicit State(LayerVector::StateSet set) : stateSet(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700391 State& operator=(const State& other) {
392 // We explicitly don't copy stateSet so that, e.g., mDrawingState
393 // always uses the Drawing StateSet.
Dan Stoza412903f2017-04-27 13:42:17 -0700394 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700395 colorMatrixChanged = other.colorMatrixChanged;
396 if (colorMatrixChanged) {
397 colorMatrix = other.colorMatrix;
398 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800399 globalShadowSettings = other.globalShadowSettings;
400
Dan Stoza412903f2017-04-27 13:42:17 -0700401 return *this;
402 }
403
404 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Dominik Laskowski68399272022-09-15 07:54:46 -0700405
406 // TODO(b/241285876): Replace deprecated DefaultKeyedVector with ftl::SmallMap.
407 DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
408
409 std::optional<size_t> getDisplayIndex(PhysicalDisplayId displayId) const {
410 for (size_t i = 0; i < displays.size(); i++) {
411 const auto& state = displays.valueAt(i);
412 if (state.physical && state.physical->id == displayId) {
413 return i;
414 }
415 }
416
417 return {};
418 }
Robert Carr2047fae2016-11-28 14:09:09 -0800419
Chia-I Wu28f320b2018-05-03 11:02:56 -0700420 bool colorMatrixChanged = true;
421 mat4 colorMatrix;
422
Vishnu Naird9e4f462023-10-06 04:05:45 +0000423 ShadowSettings globalShadowSettings;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800424 };
425
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800426 // Keeps track of pending buffers per layer handle in the transaction queue or current/drawing
427 // state before the buffers are latched. The layer owns the atomic counters and decrements the
428 // count in the main thread when dropping or latching a buffer.
429 //
430 // The binder threads increment the same counter when a new transaction containing a buffer is
431 // added to the transaction queue. The map is updated with the layer handle lifecycle updates.
432 // This is done to avoid lock contention with the main thread.
433 class BufferCountTracker {
434 public:
435 void increment(BBinder* layerHandle) {
436 std::lock_guard<std::mutex> lock(mLock);
437 auto it = mCounterByLayerHandle.find(layerHandle);
438 if (it != mCounterByLayerHandle.end()) {
439 auto [name, pendingBuffers] = it->second;
440 int32_t count = ++(*pendingBuffers);
Vishnu Nairbe0ad902024-06-27 23:38:43 +0000441 SFTRACE_INT(name.c_str(), count);
Vishnu Nair8eda69e2021-02-26 10:42:10 -0800442 } else {
443 ALOGW("Handle not found! %p", layerHandle);
444 }
445 }
446
447 void add(BBinder* layerHandle, const std::string& name, std::atomic<int32_t>* counter) {
448 std::lock_guard<std::mutex> lock(mLock);
449 mCounterByLayerHandle[layerHandle] = std::make_pair(name, counter);
450 }
451
452 void remove(BBinder* layerHandle) {
453 std::lock_guard<std::mutex> lock(mLock);
454 mCounterByLayerHandle.erase(layerHandle);
455 }
456
457 private:
458 std::mutex mLock;
459 std::unordered_map<BBinder*, std::pair<std::string, std::atomic<int32_t>*>>
460 mCounterByLayerHandle GUARDED_BY(mLock);
461 };
462
Peiyong Linf243e5e2020-08-22 17:40:59 -0700463 enum class BootStage {
464 BOOTLOADER,
465 BOOTANIMATION,
466 FINISHED,
467 };
468
Peiyong Linf243e5e2020-08-22 17:40:59 -0700469 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
470 static Dumper dumper(F&& dump) {
471 using namespace std::placeholders;
472 return std::bind(std::forward<F>(dump), _3);
473 }
474
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800475 Dumper lockedDumper(Dumper dump) {
476 return [this, dump](const DumpArgs& args, bool asProto, std::string& result) -> void {
477 TimedLock lock(mStateLock, s2ns(1), __func__);
478 if (!lock.locked()) {
479 base::StringAppendF(&result, "Dumping without lock after timeout: %s (%d)\n",
480 strerror(-lock.status), lock.status);
481 }
482 dump(args, asProto, result);
483 };
484 }
485
Peiyong Linf243e5e2020-08-22 17:40:59 -0700486 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
487 Dumper dumper(F dump) {
488 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800489 return lockedDumper(std::bind(dump, this, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700490 }
491
492 template <typename F>
493 Dumper argsDumper(F dump) {
494 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800495 return lockedDumper(std::bind(dump, this, _1, _3));
Peiyong Linf243e5e2020-08-22 17:40:59 -0700496 }
497
498 template <typename F>
499 Dumper protoDumper(F dump) {
500 using namespace std::placeholders;
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800501 return lockedDumper(std::bind(dump, this, _1, _2, _3));
502 }
503
Vishnu Naird1a05782024-03-19 04:37:38 +0000504 Dumper mainThreadDumperImpl(Dumper dumper) {
Vishnu Naird7ff85f2023-12-08 09:51:31 -0800505 return [this, dumper](const DumpArgs& args, bool asProto, std::string& result) -> void {
506 mScheduler
507 ->schedule(
508 [&args, asProto, &result, dumper]() FTL_FAKE_GUARD(kMainThreadContext)
509 FTL_FAKE_GUARD(mStateLock) { dumper(args, asProto, result); })
510 .get();
511 };
Peiyong Linf243e5e2020-08-22 17:40:59 -0700512 }
513
Vishnu Naird1a05782024-03-19 04:37:38 +0000514 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
515 Dumper mainThreadDumper(F dump) {
516 using namespace std::placeholders;
517 return mainThreadDumperImpl(std::bind(dump, this, _3));
518 }
519
520 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
521 Dumper argsMainThreadDumper(F dump) {
522 using namespace std::placeholders;
523 return mainThreadDumperImpl(std::bind(dump, this, _1, _3));
524 }
525
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700526 // Maximum allowed number of display frames that can be set through backdoor
527 static const int MAX_ALLOWED_DISPLAY_FRAMES = 2048;
Peiyong Linf243e5e2020-08-22 17:40:59 -0700528
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700529 static const size_t MAX_LAYERS = 4096;
530
Alan Dingfc6eab52024-05-02 18:28:45 -0700531 static bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
Steven Thomasd4071902020-03-24 16:02:53 -0700532 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800533
Alan Dingfc6eab52024-05-02 18:28:45 -0700534 // IBinder overrides:
535 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
536 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
537
538 // ISurfaceComposer implementation:
Alan Dingd53801c2024-05-08 16:45:29 -0700539 sp<IBinder> createVirtualDisplay(const std::string& displayName, bool isSecure,
540 const std::string& uniqueId,
541 float requestedRefreshRate = 0.0f);
542 status_t destroyVirtualDisplay(const sp<IBinder>& displayToken);
Huihong Luo07e72362022-02-14 14:26:04 -0800543 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const EXCLUDES(mStateLock) {
Ady Abrahamed3290f2021-05-17 15:12:14 -0700544 Mutex::Autolock lock(mStateLock);
545 return getPhysicalDisplayIdsLocked();
546 }
Vishnu Nair8c8db542021-09-17 19:51:45 -0700547
Huihong Luo07e72362022-02-14 14:26:04 -0800548 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const;
Pablo Gamito23780be2023-04-18 08:30:00 +0000549 status_t setTransactionState(
550 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& state,
Patrick Williamsf65da8a2024-07-24 17:11:19 +0000551 Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
Pablo Gamito23780be2023-04-18 08:30:00 +0000552 InputWindowCommands inputWindowCommands, int64_t desiredPresentTime,
553 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
554 bool hasListenerCallbacks, const std::vector<ListenerCallbacks>& listenerCallbacks,
555 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) override;
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700556 void bootFinished();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -0500557 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800558 sp<IDisplayEventConnection> createDisplayEventConnection(
Huihong Luo1b0c49f2022-03-15 19:18:21 -0700559 gui::ISurfaceComposer::VsyncSource vsyncSource =
560 gui::ISurfaceComposer::VsyncSource::eVsyncSourceApp,
Rachel Lee2248f522023-01-27 16:45:23 -0800561 EventRegistrationFlags eventRegistration = {},
562 const sp<IBinder>& layerHandle = nullptr);
Dominik Laskowskif1833852021-03-23 15:06:50 -0700563
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000564 void captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&);
John Reck7e4c4872023-11-14 18:31:03 -0500565 void captureDisplay(DisplayId, const CaptureArgs&, const sp<IScreenCaptureListener>&);
Chavi Weingartenf6fb4452024-01-23 21:10:30 +0000566 ScreenCaptureResults captureLayersSync(const LayerCaptureArgs&);
jeimysantiago9be7d0c2023-07-12 18:37:06 +0000567 void captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&);
Robert Carr108b2c72019-04-02 16:32:58 -0700568
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800569 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100570 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*)
Huihong Luoaa7fc2e2022-02-15 10:43:00 -0800571 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700572 status_t getStaticDisplayInfo(int64_t displayId, ui::StaticDisplayInfo*) EXCLUDES(mStateLock);
573 status_t getDynamicDisplayInfoFromId(int64_t displayId, ui::DynamicDisplayInfo*)
Huihong Luoa79ddf42022-02-17 00:01:38 -0800574 EXCLUDES(mStateLock);
Sally Qi6bb12822022-10-05 11:42:30 -0700575 status_t getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
576 ui::DynamicDisplayInfo*) EXCLUDES(mStateLock);
577 void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo*&, const sp<DisplayDevice>&,
578 const display::DisplaySnapshot&);
Huihong Luoca3d9a42022-02-22 11:07:34 -0800579 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken, ui::DisplayPrimaries&);
580 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode);
Huihong Luo37396db2022-02-15 10:43:00 -0800581 status_t getBootDisplayModeSupport(bool* outSupport) const;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700582 status_t setBootDisplayMode(const sp<display::DisplayToken>&, DisplayModeId);
Sally Qi0cbd08b2022-08-17 12:12:28 -0700583 status_t getOverlaySupport(gui::OverlayProperties* outProperties) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800584 status_t clearBootDisplayMode(const sp<IBinder>& displayToken);
Kriti Dang674b9372022-11-18 10:58:44 +0100585 status_t getHdrConversionCapabilities(
586 std::vector<gui::HdrConversionCapability>* hdrConversionCapaabilities) const;
Kriti Dangd432bb52023-02-09 18:21:04 +0100587 status_t setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
588 int32_t*);
Kriti Dang674b9372022-11-18 10:58:44 +0100589 status_t getHdrOutputConversionSupport(bool* outSupport) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800590 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on);
591 void setGameContentType(const sp<IBinder>& displayToken, bool on);
592 void setPowerMode(const sp<IBinder>& displayToken, int mode);
Kriti Dang49ad4132021-01-08 11:49:56 +0100593 status_t overrideHdrTypes(const sp<IBinder>& displayToken,
Huihong Luo05539a12022-02-23 10:29:40 -0800594 const std::vector<ui::Hdr>& hdrTypes);
Huihong Luo30aa4372022-10-03 14:54:12 -0700595 status_t onPullAtom(const int32_t atomId, std::vector<uint8_t>* pulledData, bool* success);
Peiyong Linc6780972018-10-28 15:24:08 -0700596 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
597 ui::Dataspace* outWideColorGamutDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800598 ui::PixelFormat* outWideColorGamutPixelFormat) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700599 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800600 ui::PixelFormat* outFormat,
601 ui::Dataspace* outDataspace,
Huihong Luo05539a12022-02-23 10:29:40 -0800602 uint8_t* outComponentMask) const;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700603 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
Huihong Luo05539a12022-02-23 10:29:40 -0800604 uint8_t componentMask, uint64_t maxFrames);
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700605 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Huihong Luo05539a12022-02-23 10:29:40 -0800606 uint64_t timestamp, DisplayedFrameStats* outStats) const;
607 status_t getProtectedContentSupport(bool* outSupported) const;
Huihong Luo37396db2022-02-15 10:43:00 -0800608 status_t isWideColorDisplay(const sp<IBinder>& displayToken, bool* outIsWideColorDisplay) const;
Dan Stoza84ab9372018-12-17 15:27:57 -0800609 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
Huihong Luo02186fb2022-02-23 14:21:54 -0800610 const sp<IRegionSamplingListener>& listener);
611 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener);
612 status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener);
613 status_t removeFpsListener(const sp<gui::IFpsListener>& listener);
614 status_t addTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
615 status_t removeTunnelModeEnabledListener(const sp<gui::ITunnelModeEnabledListener>& listener);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100616 status_t setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
Ady Abraham285f8c12022-10-11 17:12:14 -0700617 const gui::DisplayModeSpecs&);
618 status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, gui::DisplayModeSpecs*);
Huihong Luo37396db2022-02-15 10:43:00 -0800619 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, bool* outSupport) const;
John Reck22be6962021-03-10 12:59:54 -0500620 status_t setDisplayBrightness(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800621 const gui::DisplayBrightness& brightness);
John Reck88270902021-03-18 11:27:35 -0400622 status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800623 const sp<gui::IHdrLayerInfoListener>& listener);
John Reck88270902021-03-18 11:27:35 -0400624 status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
Huihong Luo37396db2022-02-15 10:43:00 -0800625 const sp<gui::IHdrLayerInfoListener>& listener);
626 status_t notifyPowerBoost(int32_t boostId);
Vishnu Nairb13bb952019-11-15 10:24:08 -0800627 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
Huihong Luo3bdef862022-03-03 11:57:19 -0800628 float lightPosY, float lightPosZ, float lightRadius);
Leon Scroggins IIIe7c51c62022-02-01 15:53:54 -0500629 status_t getDisplayDecorationSupport(
630 const sp<IBinder>& displayToken,
631 std::optional<aidl::android::hardware::graphics::common::DisplayDecorationSupport>*
Huihong Luo3bdef862022-03-03 11:57:19 -0800632 outSupport) const;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800633 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
Huihong Luo3bdef862022-03-03 11:57:19 -0800634 int8_t compatibility, int8_t changeFrameRateStrategy);
Peiyong Linf243e5e2020-08-22 17:40:59 -0700635
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000636 status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
Huihong Luo3bdef862022-03-03 11:57:19 -0800637 const gui::FrameTimelineInfo& frameTimelineInfo);
Ady Abraham74e17562020-08-24 18:18:19 -0700638
Andy Yu8c2703d2023-11-03 11:22:46 -0700639 status_t setGameModeFrameRateOverride(uid_t uid, float frameRate);
640
641 status_t setGameDefaultFrameRateOverride(uid_t uid, float frameRate);
Andy Yu2ae6b6b2021-11-18 14:51:06 -0800642
Tony Huangf3621102023-09-04 17:14:22 +0800643 status_t updateSmallAreaDetection(std::vector<std::pair<int32_t, float>>& uidThresholdMappings);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000644
Tony Huangf3621102023-09-04 17:14:22 +0800645 status_t setSmallAreaDetectionThreshold(int32_t appId, float threshold);
Tony Huang9ac5e6e2023-08-24 09:01:44 +0000646
Huihong Luo02186fb2022-02-23 14:21:54 -0800647 int getGpuContextPriority();
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800648
Huihong Luo02186fb2022-02-23 14:21:54 -0800649 status_t getMaxAcquiredBufferCount(int* buffers) const;
Ady Abraham564f9de2021-02-03 18:34:33 -0800650
Patrick Williamsacd22582023-07-12 13:47:28 -0500651 status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
652 gui::WindowInfosListenerInfo* outResult);
chaviw60c9d3e2021-06-04 12:52:17 -0500653 status_t removeWindowInfosListener(
Huihong Luo02186fb2022-02-23 14:21:54 -0800654 const sp<gui::IWindowInfosListener>& windowInfosListener) const;
chaviw60c9d3e2021-06-04 12:52:17 -0500655
Patrick Williams090ad062023-08-08 12:30:10 -0500656 status_t getStalledTransactionInfo(
657 int pid, std::optional<TransactionHandler::StalledTransactionInfo>& result);
658
Huihong Luo9ebb7a72023-06-27 17:01:50 -0700659 void updateHdcpLevels(hal::HWDisplayId hwcDisplayId, int32_t connectedLevel, int32_t maxLevel);
660
Alan Dingfc6eab52024-05-02 18:28:45 -0700661 // IBinder::DeathRecipient overrides:
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800662 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800663
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700664 // HWC2::ComposerCallback overrides:
Dominik Laskowskidc2bb802022-09-28 16:02:59 -0400665 void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700666 std::optional<hal::VsyncPeriodNanos>) override;
Huihong Luo791bef92023-09-19 21:18:45 -0700667 void onComposerHalHotplugEvent(hal::HWDisplayId, DisplayHotplugEvent) override;
Dominik Laskowski0deb06e2021-04-16 23:18:31 -0700668 void onComposerHalRefresh(hal::HWDisplayId) override;
669 void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
670 const hal::VsyncPeriodChangeTimeline&) override;
671 void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
Yichi Chen3401b562022-01-17 15:42:35 +0800672 void onComposerHalVsyncIdle(hal::HWDisplayId) override;
ramindani12bfe6b2023-02-03 13:29:19 -0800673 void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700674
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700675 // ICompositor overrides:
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500676 void configure() override REQUIRES(kMainThreadContext);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400677 bool commit(PhysicalDisplayId pacesetterId, const scheduler::FrameTargets&) override
678 REQUIRES(kMainThreadContext);
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500679 CompositeResultsPerDisplay composite(PhysicalDisplayId pacesetterId,
680 const scheduler::FrameTargeters&) override
681 REQUIRES(kMainThreadContext);
682
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700683 void sample() override;
684
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700685 // ISchedulerCallback overrides:
Dominik Laskowski66295432023-03-14 12:25:36 -0400686 void requestHardwareVsync(PhysicalDisplayId, bool) override;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400687 void requestDisplayModes(std::vector<display::DisplayModeRequest>) override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800688 void kernelTimerChanged(bool expired) override;
Ady Abraham822ecbd2023-07-07 16:16:09 -0700689 void onChoreographerAttached() override;
ramindaniae645822024-01-11 10:57:29 -0800690 void onExpectedPresentTimePosted(TimePoint expectedPresentTime, ftl::NonNull<DisplayModePtr>,
691 Fps renderRate) override;
Ady Abraham14beed72024-05-15 17:16:45 -0700692 void onCommitNotComposited(PhysicalDisplayId pacesetterDisplayId) override
693 REQUIRES(kMainThreadContext);
Ady Abrahameba039c2024-07-10 17:45:29 -0700694 void vrrDisplayIdle(bool idle) override;
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700695
jimmyshiu4e211772023-06-15 15:18:38 +0000696 // ICEPowerCallback overrides:
697 void notifyCpuLoadUp() override;
698
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400699 using KernelIdleTimerController = scheduler::RefreshRateSelector::KernelIdleTimerController;
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400700
ramindani32cf0602022-03-02 02:30:29 +0000701 // Get the controller and timeout that will help decide how the kernel idle timer will be
702 // configured and what value to use as the timeout.
703 std::pair<std::optional<KernelIdleTimerController>, std::chrono::milliseconds>
Dominik Laskowski6e465152022-09-28 11:00:25 -0400704 getKernelIdleTimerProperties(PhysicalDisplayId) REQUIRES(mStateLock);
Dominik Laskowski43839672024-08-04 02:01:48 -0400705
Lloyd Pique30db6402023-06-26 18:56:51 +0000706 // Show spinner with refresh rate overlay
707 bool mRefreshRateOverlaySpinner = false;
708 // Show render rate with refresh rate overlay
709 bool mRefreshRateOverlayRenderRate = false;
710 // Show render rate overlay offseted to the middle of the screen (e.g. for circular displays)
711 bool mRefreshRateOverlayShowInMiddle = false;
Sally Qi147581b2023-06-27 11:55:34 -0700712 // Show hdr sdr ratio overlay
713 bool mHdrSdrRatioOverlay = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700714
Bart Sears2d7e7f82024-07-13 19:42:29 +0000715 void setDesiredMode(display::DisplayModeRequest&&) REQUIRES(mStateLock);
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400716
Ady Abraham38027262023-10-17 16:58:25 -0700717 status_t setActiveModeFromBackdoor(const sp<display::DisplayToken>&, DisplayModeId, Fps minFps,
718 Fps maxFps);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400719
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400720 void initiateDisplayModeChanges() REQUIRES(kMainThreadContext) REQUIRES(mStateLock);
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400721 void finalizeDisplayModeChange(PhysicalDisplayId) REQUIRES(kMainThreadContext)
Dominik Laskowskib2fc4232024-07-15 08:24:49 -0400722 REQUIRES(mStateLock);
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400723
Dominik Laskowski5c989f52024-04-11 13:57:14 -0400724 void dropModeRequest(PhysicalDisplayId) REQUIRES(kMainThreadContext);
725 void applyActiveMode(PhysicalDisplayId) REQUIRES(kMainThreadContext);
Dominik Laskowski59746512023-11-19 09:30:24 -0500726
Marin Shalamanov5801c942020-12-17 17:00:13 +0100727 // Called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700728 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700729 REQUIRES(mStateLock, kMainThreadContext);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800730
Dominik Laskowskif2595442022-08-29 13:51:57 -0700731 // Returns the preferred mode for PhysicalDisplayId if the Scheduler has selected one for that
732 // display. Falls back to the display's defaultModeId otherwise.
Ady Abrahamace3d052022-11-17 16:25:05 -0800733 ftl::Optional<scheduler::FrameRateMode> getPreferredDisplayMode(
Dominik Laskowski530d6bd2022-10-10 16:55:54 -0400734 PhysicalDisplayId, DisplayModeId defaultModeId) const REQUIRES(mStateLock);
Dominik Laskowskif2595442022-08-29 13:51:57 -0700735
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400736 status_t setDesiredDisplayModeSpecsInternal(
737 const sp<DisplayDevice>&, const scheduler::RefreshRateSelector::PolicyVariant&)
Dominik Laskowski36dced82022-09-02 09:24:00 -0700738 EXCLUDES(mStateLock) REQUIRES(kMainThreadContext);
Ady Abraham838de062019-02-04 10:24:03 -0800739
Dominik Laskowski3f726402022-11-21 17:21:22 -0500740 // TODO(b/241285191): Look up RefreshRateSelector on Scheduler to remove redundant parameter.
741 status_t applyRefreshRateSelectorPolicy(PhysicalDisplayId,
Dominik Laskowski1746afd2024-04-10 19:21:37 -0400742 const scheduler::RefreshRateSelector&)
Dominik Laskowski3f726402022-11-21 17:21:22 -0500743 REQUIRES(mStateLock, kMainThreadContext);
744
Vishnu Nair878911f2024-03-27 22:20:24 -0700745 void commitTransactions() REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700746 void commitTransactionsLocked(uint32_t transactionFlags)
747 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700748 void doCommitTransactions() REQUIRES(mStateLock);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800749
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000750 std::vector<std::pair<Layer*, LayerFE*>> moveSnapshotsToCompositionArgs(
Vishnu Nair7be27602024-03-28 20:27:09 -0700751 compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly)
752 REQUIRES(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000753 void moveSnapshotsFromCompositionArgs(compositionengine::CompositionRefreshArgs& refreshArgs,
Vishnu Nair7be27602024-03-28 20:27:09 -0700754 const std::vector<std::pair<Layer*, LayerFE*>>& layers)
755 REQUIRES(kMainThreadContext);
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700756 // Return true if we must composite this frame
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000757 bool updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000758 bool& out) REQUIRES(kMainThreadContext);
Vishnu Nair7be27602024-03-28 20:27:09 -0700759 void updateLayerHistory(nsecs_t now) REQUIRES(kMainThreadContext);
Dan Stoza6b9454d2014-11-07 16:00:59 -0800760
Vishnu Nair7be27602024-03-28 20:27:09 -0700761 void updateInputFlinger(VsyncId vsyncId, TimePoint frameTime) REQUIRES(kMainThreadContext);
Dominik Laskowski298b08e2022-02-15 13:45:02 -0800762 void persistDisplayBrightness(bool needsComposite) REQUIRES(kMainThreadContext);
Vishnu Nair03ccbd62021-12-01 17:21:16 -0800763 void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,
Vishnu Nair7be27602024-03-28 20:27:09 -0700764 std::vector<gui::DisplayInfo>& outDisplayInfos)
765 REQUIRES(kMainThreadContext);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800766 void commitInputWindowCommands() REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -0700767 void updateCursorAsync() REQUIRES(kMainThreadContext);
Dominik Laskowski08d05c22020-07-22 00:05:08 -0700768
Dominik Laskowski59db9562022-10-27 16:18:53 -0400769 void initScheduler(const sp<const DisplayDevice>&) REQUIRES(kMainThreadContext, mStateLock);
Dominik Laskowski14956dc2023-02-22 13:43:57 -0500770
Peiyong Linf243e5e2020-08-22 17:40:59 -0700771 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700772 * Transactions
773 */
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000774 bool applyTransactionState(const FrameTimelineInfo& info,
775 std::vector<ResolvedComposerState>& state,
776 Vector<DisplayState>& displays, uint32_t flags,
777 const InputWindowCommands& inputWindowCommands,
778 const int64_t desiredPresentTime, bool isAutoTimestamp,
779 const std::vector<uint64_t>& uncacheBufferIds,
780 const int64_t postTime, bool hasListenerCallbacks,
781 const std::vector<ListenerCallbacks>& listenerCallbacks,
782 int originPid, int originUid, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700783 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700784 // Flush pending transactions that were presented after desiredPresentTime.
Vishnu Nair42ad3192023-01-24 19:17:59 -0800785 // For test only
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000786 bool flushTransactionQueues() REQUIRES(kMainThreadContext);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800787
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000788 bool applyTransactions(std::vector<TransactionState>&) REQUIRES(kMainThreadContext);
Vishnu Nair878911f2024-03-27 22:20:24 -0700789 bool applyAndCommitDisplayTransactionStatesLocked(std::vector<TransactionState>& transactions)
790 REQUIRES(kMainThreadContext, mStateLock);
Vishnu Nair42ad3192023-01-24 19:17:59 -0800791
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700792 // Returns true if there is at least one transaction that needs to be flushed
Vishnu Nair7be27602024-03-28 20:27:09 -0700793 bool transactionFlushNeeded() REQUIRES(kMainThreadContext);
794 void addTransactionReadyFilters() REQUIRES(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700795 TransactionHandler::TransactionReadiness transactionReadyTimelineCheck(
796 const TransactionHandler::TransactionFlushState& flushState)
797 REQUIRES(kMainThreadContext);
798 TransactionHandler::TransactionReadiness transactionReadyBufferCheck(
799 const TransactionHandler::TransactionFlushState& flushState)
800 REQUIRES(kMainThreadContext);
Ady Abrahame1bfaac2022-02-22 21:32:08 -0800801
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000802 uint32_t updateLayerCallbacksAndStats(const FrameTimelineInfo&, ResolvedComposerState&,
803 int64_t desiredPresentTime, bool isAutoTimestamp,
Chavi Weingartenc78f53c2023-04-14 18:50:53 +0000804 int64_t postTime, uint64_t transactionId)
Vishnu Nair7be27602024-03-28 20:27:09 -0700805 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700806 uint32_t getTransactionFlags() const;
807
Dominik Laskowski94000c42022-03-17 12:55:14 -0700808 // Sets the masked bits, and schedules a commit if needed.
809 void setTransactionFlags(uint32_t mask, TransactionSchedule = TransactionSchedule::Late,
Dominik Laskowski1f6fc702022-03-21 08:34:50 -0700810 const sp<IBinder>& applyToken = nullptr,
811 FrameHint = FrameHint::kActive);
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700812
813 // Clears and returns the masked bits.
814 uint32_t clearTransactionFlags(uint32_t mask);
815
ramindani4d48f902021-09-20 21:07:45 +0000816 static LatchUnsignaledConfig getLatchUnsignaledConfig();
Vishnu Nair4d9cef92023-06-24 22:34:41 +0000817 bool shouldLatchUnsignaled(const layer_state_t&, size_t numStates, bool firstTransaction) const;
Shuangxi Xianga97d59d2024-08-27 07:28:20 +0000818 bool applyTransactionsLocked(std::vector<TransactionState>& transactions)
Vishnu Nair7be27602024-03-28 20:27:09 -0700819 REQUIRES(mStateLock, kMainThreadContext);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800820 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800821 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
822 REQUIRES(mStateLock);
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700823 bool frameIsEarly(TimePoint expectedPresentTime, VsyncId) const;
824
Peiyong Linf243e5e2020-08-22 17:40:59 -0700825 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700826 * Layer management
827 */
Vishnu Naircb8be502022-10-12 19:03:23 +0000828 status_t createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800829
Vishnu Nair7fb9e5a2021-11-08 12:44:05 -0800830 status_t createBufferStateLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
831 sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700832
Vishnu Nair84125ac2021-12-02 08:47:48 -0800833 status_t createEffectLayer(const LayerCreationArgs& args, sp<IBinder>* outHandle,
Vishnu Nairfa247b12020-02-11 08:58:26 -0800834 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700835
Vishnu Nair84125ac2021-12-02 08:47:48 -0800836 status_t mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000837 gui::CreateSurfaceResult& outResult);
chaviwfe94a222019-08-21 13:52:59 -0700838
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000839 status_t mirrorDisplay(DisplayId displayId, const LayerCreationArgs& args,
Patrick Williamsa361de62022-10-06 20:34:10 +0000840 gui::CreateSurfaceResult& outResult);
Chavi Weingarten7043a7d2022-07-19 23:40:35 +0000841
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700842 // add a layer to SurfaceFlinger
Vishnu Nair1391de22023-03-05 19:56:14 -0800843 status_t addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
Vishnu Naircb8be502022-10-12 19:03:23 +0000844 const sp<Layer>& layer, const wp<Layer>& parentLayer,
Garfield Tandbc93d72021-10-26 18:28:57 -0700845 uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700846
Melody Hsu793f8362024-01-08 20:00:35 +0000847 // Creates a promise for a future release fence for a layer. This allows for
848 // the layer to keep track of when its buffer can be released.
849 void attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE, ui::LayerStack layerStack);
850
851 // Checks if a protected layer exists in a list of layers.
Melody Hsu8c42cf12024-06-05 00:07:03 +0000852 bool layersHasProtectedLayer(const std::vector<sp<LayerFE>>& layers) const;
853
854 using OutputCompositionState = compositionengine::impl::OutputCompositionState;
855
Vishnu Nair5a93ccb2024-06-26 00:38:32 +0000856 std::optional<OutputCompositionState> getSnapshotsFromMainThread(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000857 RenderAreaBuilderVariant& renderAreaBuilder,
858 GetLayerSnapshotsFunction getLayerSnapshotsFn, std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu82d524e2024-02-23 02:37:38 +0000859
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000860 void captureScreenCommon(RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
861 ui::Size bufferSize, ui::PixelFormat, bool allowProtected,
862 bool grayscale, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000863
Melody Hsu8c42cf12024-06-05 00:07:03 +0000864 std::optional<OutputCompositionState> getDisplayStateFromRenderAreaBuilder(
865 RenderAreaBuilderVariant& renderAreaBuilder) REQUIRES(kMainThreadContext);
Melody Hsu335ef3e2024-05-31 22:58:40 +0000866
Melody Hsu8c42cf12024-06-05 00:07:03 +0000867 // Legacy layer raw pointer is not safe to access outside the main thread.
868 // Creates a new vector consisting only of LayerFEs, which can be safely
869 // accessed outside the main thread.
870 std::vector<sp<LayerFE>> extractLayerFEs(
871 const std::vector<std::pair<Layer*, sp<LayerFE>>>& layers) const;
Melody Hsu335ef3e2024-05-31 22:58:40 +0000872
Melody Hsu82d524e2024-02-23 02:37:38 +0000873 ftl::SharedFuture<FenceResult> captureScreenshot(
Melody Hsu8c42cf12024-06-05 00:07:03 +0000874 const RenderAreaBuilderVariant& renderAreaBuilder,
875 const std::shared_ptr<renderengine::ExternalTexture>& buffer, bool regionSampling,
876 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>& captureListener,
877 std::optional<OutputCompositionState>& displayState,
878 std::vector<sp<LayerFE>>& layerFEs);
879
880 ftl::SharedFuture<FenceResult> captureScreenshotLegacy(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000881 RenderAreaBuilderVariant, GetLayerSnapshotsFunction,
Sally Qi59a9f502021-10-12 18:53:23 +0000882 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
Chavi Weingarten18fa7c62023-11-28 21:16:03 +0000883 bool grayscale, bool isProtected, const sp<IScreenCaptureListener>&);
Melody Hsu82d524e2024-02-23 02:37:38 +0000884
Melody Hsu793f8362024-01-08 20:00:35 +0000885 ftl::SharedFuture<FenceResult> renderScreenImpl(
Melody Hsu2ffa36b2024-05-08 03:51:46 +0000886 std::unique_ptr<const RenderArea>,
Melody Hsu793f8362024-01-08 20:00:35 +0000887 const std::shared_ptr<renderengine::ExternalTexture>&, bool regionSampling,
888 bool grayscale, bool isProtected, ScreenCaptureResults&,
Melody Hsu8c42cf12024-06-05 00:07:03 +0000889 std::optional<OutputCompositionState>& displayState,
890 std::vector<std::pair<Layer*, sp<LayerFE>>>& layers,
891 std::vector<sp<LayerFE>>& layerFEs);
Melody Hsu793f8362024-01-08 20:00:35 +0000892
Romain Guy11d63f42017-07-20 12:47:14 -0700893 void readPersistentProperties();
894
rnleeed20fa42021-08-10 18:00:03 -0700895 uint32_t getMaxAcquiredBufferCountForCurrentRefreshRate(uid_t uid) const;
Ady Abraham899dcdb2021-06-15 16:56:21 -0700896
Peiyong Linf243e5e2020-08-22 17:40:59 -0700897 /*
Mathias Agopian87baae12012-07-31 12:38:26 -0700898 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700899 */
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700900
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400901 // Called during boot and restart after system_server death, setting the stage for bootanimation
902 // before DisplayManager takes over.
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400903 void initializeDisplays() REQUIRES(kMainThreadContext);
Andy McFadden13a082e2012-08-24 10:16:42 -0700904
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700905 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
906 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700907 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700908 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700909
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700910 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski80872bd2022-11-15 11:34:33 -0500911 return mDisplays.get(displayToken)
912 .or_else(ftl::static_ref<sp<DisplayDevice>>([] { return nullptr; }))
913 .value();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700914 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700915
Ady Abraham690f4612021-07-01 23:24:03 -0700916 sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
917 REQUIRES(mStateLock) {
918 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(id);
919 }
920
921 sp<DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) REQUIRES(mStateLock) {
922 if (const auto token = getPhysicalDisplayTokenLocked(id)) {
923 return getDisplayDeviceLocked(token);
924 }
925 return nullptr;
926 }
927
Dominik Laskowski3c363242022-04-07 10:44:12 -0700928 sp<const DisplayDevice> getDisplayDeviceLocked(DisplayId id) const REQUIRES(mStateLock) {
929 // TODO(b/182939859): Replace tokens with IDs for display lookup.
930 return findDisplay([id](const auto& display) { return display.getId() == id; });
931 }
932
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500933 std::shared_ptr<compositionengine::Display> getCompositionDisplayLocked(DisplayId id) const
934 REQUIRES(mStateLock) {
935 if (const auto display = getDisplayDeviceLocked(id)) {
936 return display->getCompositionDisplay();
937 }
938 return nullptr;
939 }
940
Dominik Laskowskia0858db2024-07-23 16:45:11 -0400941 // Returns the primary display or (for foldables) the active display.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700942 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700943 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700944 }
945
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700946 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskie591b552022-09-09 10:44:56 -0700947 return getDisplayDeviceLocked(mActiveDisplayId);
Michael Wright28f24d02016-07-12 13:30:53 -0700948 }
949
Ady Abraham3efa3942021-06-24 19:01:25 -0700950 sp<const DisplayDevice> getDefaultDisplayDevice() const EXCLUDES(mStateLock) {
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700951 Mutex::Autolock lock(mStateLock);
952 return getDefaultDisplayDeviceLocked();
953 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200954
Dominik Laskowski6e465152022-09-28 11:00:25 -0400955 using DisplayDeviceAndSnapshot = std::pair<sp<DisplayDevice>, display::DisplaySnapshotRef>;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700956
957 // Combinator for ftl::Optional<PhysicalDisplay>::and_then.
958 auto getDisplayDeviceAndSnapshot() REQUIRES(mStateLock) {
959 return [this](const display::PhysicalDisplay& display) REQUIRES(
960 mStateLock) -> ftl::Optional<DisplayDeviceAndSnapshot> {
961 if (auto device = getDisplayDeviceLocked(display.snapshot().displayId())) {
962 return std::make_pair(std::move(device), display.snapshotRef());
963 }
964
965 return {};
966 };
967 }
968
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700969 // Returns the first display that matches a `bool(const DisplayDevice&)` predicate.
970 template <typename Predicate>
971 sp<DisplayDevice> findDisplay(Predicate p) const REQUIRES(mStateLock) {
972 const auto it = std::find_if(mDisplays.begin(), mDisplays.end(),
Dominik Laskowski3de67272023-08-09 13:15:31 -0400973 [&](const auto& pair)
974 REQUIRES(mStateLock) { return p(*pair.second); });
Dominik Laskowski7b9bf4c2021-03-18 12:21:29 -0700975
976 return it == mDisplays.end() ? nullptr : it->second;
977 }
978
Ady Abrahamed3290f2021-05-17 15:12:14 -0700979 std::vector<PhysicalDisplayId> getPhysicalDisplayIdsLocked() const REQUIRES(mStateLock);
980
Mathias Agopian87baae12012-07-31 12:38:26 -0700981 // mark a region of a layer stack dirty. this updates the dirty
982 // region of all screens presenting this layer stack.
Vishnu Nair3af0ec02023-02-10 04:13:48 +0000983 void invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700984
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700985 ui::LayerFilter makeLayerFilterForDisplay(DisplayId displayId, ui::LayerStack layerStack)
986 REQUIRES(mStateLock) {
987 return {layerStack,
988 PhysicalDisplayId::tryCast(displayId)
989 .and_then(display::getPhysicalDisplay(mPhysicalDisplays))
990 .transform(&display::PhysicalDisplay::isInternal)
991 .value_or(false)};
Ady Abrahamed3290f2021-05-17 15:12:14 -0700992 }
993
Peiyong Linf243e5e2020-08-22 17:40:59 -0700994 /*
Mathias Agopian86303202012-07-24 22:46:10 -0700995 * H/W composer
996 */
Marin Shalamanov6e840172020-12-14 22:13:28 +0100997 // The following thread safety rules apply when accessing HWComposer:
998 // 1. When reading display state from HWComposer on the main thread, it's not necessary to
999 // acquire mStateLock.
1000 // 2. When accessing HWComposer on a thread other than the main thread, we always
Lloyd Pique441d5042018-10-18 16:49:51 -07001001 // need to acquire mStateLock. This is because the main thread could be
Marin Shalamanov6e840172020-12-14 22:13:28 +01001002 // in the process of writing display state, e.g. creating or destroying a display.
Lloyd Pique441d5042018-10-18 16:49:51 -07001003 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -07001004
Peiyong Linf243e5e2020-08-22 17:40:59 -07001005 /*
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001006 * Compositing
1007 */
Leon Scroggins III5b581492023-10-31 14:29:41 -04001008 void onCompositionPresented(PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters&,
1009 nsecs_t presentStartTime) REQUIRES(kMainThreadContext);
Mathias Agopian4da75192010-08-10 17:19:56 -07001010
Peiyong Linf243e5e2020-08-22 17:40:59 -07001011 /*
Jamie Gennis0bceb842012-08-23 20:19:38 -07001012 * Display management
1013 */
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001014 std::pair<DisplayModes, DisplayModePtr> loadDisplayModes(PhysicalDisplayId) const
1015 REQUIRES(mStateLock);
1016
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001017 // TODO(b/241285876): Move to DisplayConfigurator.
1018 //
1019 // Returns whether displays have been added/changed/removed, i.e. whether ICompositor should
1020 // commit display transactions.
1021 bool configureLocked() REQUIRES(mStateLock) REQUIRES(kMainThreadContext)
1022 EXCLUDES(mHotplugMutex);
1023
Dominik Laskowski6e465152022-09-28 11:00:25 -04001024 // Returns the active mode ID, or nullopt on hotplug failure.
1025 std::optional<DisplayModeId> processHotplugConnect(PhysicalDisplayId, hal::HWDisplayId,
1026 DisplayIdentificationInfo&&,
1027 const char* displayString)
1028 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb8267b2024-04-26 16:23:07 -04001029 void processHotplugDisconnect(PhysicalDisplayId, const char* displayString)
1030 REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskibb66e632022-08-17 08:00:25 -07001031
Lloyd Pique542307f2018-10-19 13:24:08 -07001032 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -07001033 const wp<IBinder>& displayToken,
1034 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -07001035 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +01001036 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001037 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001038 void processDisplayChangesLocked() REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001039 void processDisplayRemoved(const wp<IBinder>& displayToken)
1040 REQUIRES(mStateLock, kMainThreadContext);
Marin Shalamanovae685592020-02-12 17:12:22 +01001041 void processDisplayChanged(const wp<IBinder>& displayToken,
1042 const DisplayDeviceState& currentState,
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001043 const DisplayDeviceState& drawingState)
1044 REQUIRES(mStateLock, kMainThreadContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001045
Peiyong Linf243e5e2020-08-22 17:40:59 -07001046 /*
Dominik Laskowskic2867142019-01-21 11:33:38 -08001047 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001048 */
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001049 sp<display::DisplayToken> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
Marin Shalamanova524a092020-07-27 21:39:55 +02001050 REQUIRES(mStateLock) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001051 return mPhysicalDisplays.get(displayId)
1052 .transform([](const display::PhysicalDisplay& display) { return display.token(); })
Dominik Laskowski80872bd2022-11-15 11:34:33 -05001053 .or_else([] { return std::optional<sp<display::DisplayToken>>(nullptr); })
1054 .value();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001055 }
1056
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001057 std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001058 const sp<display::DisplayToken>&) const REQUIRES(mStateLock);
Dominik Laskowski075d3172018-05-24 15:50:06 -07001059
Dominik Laskowski3c363242022-04-07 10:44:12 -07001060 // Returns the first display connected at boot.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001061 //
Dominik Laskowski3c363242022-04-07 10:44:12 -07001062 // TODO(b/229851933): SF conflates the primary display with the first display connected at boot,
1063 // which typically has DisplayConnectionType::Internal. (Theoretically, it must be an internal
1064 // display because SF does not support disconnecting it, though in practice HWC may circumvent
1065 // this limitation.)
1066 sp<IBinder> getPrimaryDisplayTokenLocked() const REQUIRES(mStateLock) {
1067 return getPhysicalDisplayTokenLocked(getPrimaryDisplayIdLocked());
Dominik Laskowski075d3172018-05-24 15:50:06 -07001068 }
1069
Dominik Laskowski3c363242022-04-07 10:44:12 -07001070 PhysicalDisplayId getPrimaryDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -07001071 return getHwComposer().getPrimaryDisplayId();
Dominik Laskowski075d3172018-05-24 15:50:06 -07001072 }
1073
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001074 // Toggles use of HAL/GPU virtual displays.
1075 void enableHalVirtualDisplays(bool);
1076
1077 // Virtual display lifecycle for ID generation and HAL allocation.
Dominik Laskowski263eec42021-07-21 23:13:24 -07001078 VirtualDisplayId acquireVirtualDisplay(ui::Size, ui::PixelFormat) REQUIRES(mStateLock);
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001079 void releaseVirtualDisplay(VirtualDisplayId);
1080
Dominik Laskowski3de67272023-08-09 13:15:31 -04001081 // Returns a display other than `mActiveDisplayId` that can be activated, if any.
1082 sp<DisplayDevice> getActivatableDisplay() const REQUIRES(mStateLock, kMainThreadContext);
1083
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001084 void onActiveDisplayChangedLocked(const DisplayDevice* inactiveDisplayPtr,
1085 const DisplayDevice& activeDisplay)
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001086 REQUIRES(mStateLock, kMainThreadContext);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001087
Dominik Laskowski39dfc942023-02-08 16:27:05 -05001088 void onActiveDisplaySizeChanged(const DisplayDevice&);
Ady Abrahamed3290f2021-05-17 15:12:14 -07001089
Dominik Laskowskic2867142019-01-21 11:33:38 -08001090 /*
1091 * Debugging & dumpsys
1092 */
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001093 void dumpAll(const DumpArgs& args, const std::string& compositionLayers,
1094 std::string& result) const EXCLUDES(mStateLock);
Vishnu Nair3cc15a42023-06-30 06:20:22 +00001095 void dumpHwcLayersMinidump(std::string& result) const REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001096
1097 void appendSfConfigString(std::string& result) const;
Vishnu Nair7be27602024-03-28 20:27:09 -07001098 void listLayers(std::string& result) const REQUIRES(kMainThreadContext);
1099 void dumpStats(const DumpArgs& args, std::string& result) const
1100 REQUIRES(mStateLock, kMainThreadContext);
1101 void clearStats(const DumpArgs& args, std::string& result) REQUIRES(kMainThreadContext);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001102 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -07001103 void dumpFrameTimeline(const DumpArgs& args, std::string& result) const;
Dominik Laskowski8792c112022-07-12 09:03:39 -07001104 void logFrameStats(TimePoint now) REQUIRES(kMainThreadContext);
Jamie Gennis6547ff42013-07-16 20:12:42 -07001105
Dominik Laskowski03cfce82022-11-02 12:13:29 -04001106 void dumpScheduler(std::string& result) const REQUIRES(mStateLock);
1107 void dumpEvents(std::string& result) const REQUIRES(mStateLock);
1108 void dumpVsync(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001109
1110 void dumpCompositionDisplays(std::string& result) const REQUIRES(mStateLock);
1111 void dumpDisplays(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001112 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -07001113 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001114 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
John Reck2a3d29d2023-08-17 17:45:01 -04001115 void dumpHdrInfo(std::string& result) const REQUIRES(mStateLock);
Vishnu Naird7ff85f2023-12-08 09:51:31 -08001116 void dumpFrontEnd(std::string& result) REQUIRES(kMainThreadContext);
1117 void dumpVisibleFrontEnd(std::string& result) REQUIRES(mStateLock, kMainThreadContext);
Dominik Laskowski0acc3842022-04-07 11:23:42 -07001118
Vishnu Nair7be27602024-03-28 20:27:09 -07001119 perfetto::protos::LayersProto dumpDrawingStateProto(uint32_t traceFlags) const
1120 REQUIRES(kMainThreadContext);
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001121 google::protobuf::RepeatedPtrField<perfetto::protos::DisplayProto> dumpDisplayProto() const;
Kean Mariotti639b54f2023-04-20 12:06:29 +00001122 void doActiveLayersTracingIfNeeded(bool isCompositionComputed, bool visibleRegionDirty,
1123 TimePoint, VsyncId) REQUIRES(kMainThreadContext);
1124 perfetto::protos::LayersSnapshotProto takeLayersSnapshotProto(uint32_t flags, TimePoint,
1125 VsyncId, bool visibleRegionDirty)
Vishnu Nair81750622023-03-08 15:02:06 -08001126 REQUIRES(kMainThreadContext);
chaviw0a398992021-08-13 10:13:01 -05001127
Alec Mouri6b9e9912020-01-21 10:50:24 -08001128 // Dumps state from HW Composer
1129 void dumpHwc(std::string& result) const;
Kean Mariotti4ba343c2023-04-19 13:31:02 +00001130 perfetto::protos::LayersProto dumpProtoFromMainThread(
1131 uint32_t traceFlags = LayerTracing::TRACE_ALL) EXCLUDES(mStateLock);
Dan Stoza269dc4d2021-01-15 15:07:43 -08001132 void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -07001133
Dominik Laskowskic2867142019-01-21 11:33:38 -08001134 status_t doDump(int fd, const DumpArgs& args, bool asProto);
1135
Nataniel Borges8e7dc722019-02-28 15:10:28 -08001136 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -08001137
1138 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
1139 return doDump(fd, args, asProto);
1140 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001141
chaviw17ac24b2021-01-28 18:50:05 -08001142 static mat4 calculateColorMatrix(float saturation);
1143
Chia-I Wu28f320b2018-05-03 11:02:56 -07001144 void updateColorMatrixLocked();
1145
Peiyong Linf243e5e2020-08-22 17:40:59 -07001146 // Verify that transaction is being called by an approved process:
1147 // either AID_GRAPHICS or AID_SYSTEM.
1148 status_t CheckTransactCodeCredentials(uint32_t code);
1149
Ady Abrahame46243a2021-02-23 19:33:49 -08001150 // Add transaction to the Transaction Queue
Ady Abrahame46243a2021-02-23 19:33:49 -08001151
Peiyong Linf243e5e2020-08-22 17:40:59 -07001152 /*
1153 * Generic Layer Metadata
1154 */
1155 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1156
Lloyd Pique30db6402023-06-26 18:56:51 +00001157 static int calculateMaxAcquiredBufferCount(Fps refreshRate,
1158 std::chrono::nanoseconds presentLatency);
Ady Abraham899dcdb2021-06-15 16:56:21 -07001159 int getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) const;
Ady Abraham564f9de2021-02-03 18:34:33 -08001160
Vishnu Nair7aa0eb72023-01-24 03:59:27 +00001161 bool isHdrLayer(const frontend::LayerSnapshot& snapshot) const;
John Reck49d9ad32022-02-23 19:03:31 -05001162
ramindani06e518e2022-03-14 18:47:53 +00001163 ui::Rotation getPhysicalDisplayOrientation(DisplayId, bool isPrimary) const
1164 REQUIRES(mStateLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001165 void traverseLegacyLayers(const LayerVector::Visitor& visitor) const
1166 REQUIRES(kMainThreadContext);
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001167
1168 void initBootProperties();
Vishnu Nair8c5b7002023-08-17 21:03:57 -07001169 void initTransactionTraceWriter();
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001170
Lloyd Pique30db6402023-06-26 18:56:51 +00001171 surfaceflinger::Factory& mFactory;
1172 pid_t mPid;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001173
1174 // TODO: b/328459745 - Encapsulate in a SystemProperties object.
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001175 utils::OnceFuture mInitBootPropsFuture;
Dominik Laskowskiefb131e2024-02-16 10:57:40 -05001176
Dominik Laskowskid4a22752024-03-08 17:39:04 -05001177 utils::OnceFuture mRenderEnginePrimeCacheFuture;
Ady Abrahamfe2a6db2021-06-09 15:41:37 -07001178
Leon Scroggins III67388622023-02-06 20:36:20 -05001179 // mStateLock has conventions related to the current thread, because only
1180 // the main thread should modify variables protected by mStateLock.
1181 // - read access from a non-main thread must lock mStateLock, since the main
1182 // thread may modify these variables.
1183 // - write access from a non-main thread is not permitted.
1184 // - read access from the main thread can use an ftl::FakeGuard, since other
1185 // threads must not modify these variables.
1186 // - write access from the main thread must lock mStateLock, since another
1187 // thread may be reading these variables.
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001188 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001189 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001190 std::atomic<int32_t> mTransactionFlags = 0;
Vishnu Nair7891e962021-11-11 12:07:21 -08001191 std::atomic<uint32_t> mUniqueTransactionId = 1;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001192
Brian Lindahl439afad2022-11-14 11:16:55 -07001193 // Buffers that have been discarded by clients and need to be evicted from per-layer caches so
1194 // the graphics memory can be immediately freed.
1195 std::vector<uint64_t> mBufferIdsToUncache;
1196
Chia-I Wu28f320b2018-05-03 11:02:56 -07001197 // global color transform states
1198 Daltonizer mDaltonizer;
1199 float mGlobalSaturationFactor = 1.0f;
1200 mat4 mClientColorMatrix;
1201
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001202 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001203 bool mLayersRemoved = false;
1204 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001205
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -07001206 std::atomic_bool mMustComposite = false;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001207 std::atomic_bool mGeometryDirty = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001208
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001209 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001210 const nsecs_t mBootTime = systemTime();
Lloyd Pique30db6402023-06-26 18:56:51 +00001211 bool mIsUserBuild = true;
Dominik Laskowskie62606d2024-02-22 11:42:13 -05001212 bool mHasReliablePresentFences = false;
Mathias Agopian3094df32012-06-18 18:06:45 -07001213
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001214 // Can only accessed from the main thread, these members
1215 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001216 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001217 bool mVisibleRegionsDirty = false;
Robert Carre450fb52021-06-11 13:21:09 -07001218
John Reck68796592023-01-25 13:47:12 -05001219 bool mHdrLayerInfoChanged = false;
1220
Robert Carr167bdde2021-07-28 11:26:51 -07001221 // Used to ensure we omit a callback when HDR layer info listener is newly added but the
1222 // scene hasn't changed
1223 bool mAddingHDRLayerInfoListener = false;
Lloyd Pique30db6402023-06-26 18:56:51 +00001224 bool mIgnoreHdrCameraLayers = false;
Robert Carr167bdde2021-07-28 11:26:51 -07001225
Robert Carre450fb52021-06-11 13:21:09 -07001226 // Set during transaction application stage to track if the input info or children
1227 // for a layer has changed.
1228 // TODO: Also move visibleRegions over to a boolean system.
Arthur Hung9ed43392022-05-27 06:31:57 +00001229 bool mUpdateInputInfo = false;
Robert Carre450fb52021-06-11 13:21:09 -07001230 bool mSomeChildrenChanged;
Robert Carrb552ff52021-06-11 13:35:54 -07001231 bool mForceTransactionDisplayChange = false;
Ady Abraham822ecbd2023-07-07 16:16:09 -07001232 bool mUpdateAttachedChoreographer = false;
Robert Carre450fb52021-06-11 13:21:09 -07001233
Vishnu Nair39a74a92024-07-29 19:01:50 +00001234 struct LayerIntHash {
1235 size_t operator()(const std::pair<sp<Layer>, gui::GameMode>& k) const {
1236 return std::hash<Layer*>()(k.first.get()) ^
1237 std::hash<int32_t>()(static_cast<int32_t>(k.second));
1238 }
1239 };
1240
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001241 // TODO(b/238781169) validate these on composition
Alec Mouri5c9c9602020-09-01 15:10:40 -07001242 // Tracks layers that have pending frames which are candidates for being
Alec Mouri2f7d9ae2020-11-30 19:32:33 -08001243 // latched.
Vishnu Nair39a74a92024-07-29 19:01:50 +00001244 std::unordered_set<std::pair<sp<Layer>, gui::GameMode>, LayerIntHash> mLayersWithQueuedFrames;
Vishnu Nair7ee4f462023-04-19 09:54:09 -07001245 std::unordered_set<sp<Layer>, SpHash<Layer>> mLayersWithBuffersRemoved;
Vishnu Nair6f209e22023-08-04 16:33:23 +00001246 std::unordered_set<uint32_t> mLayersIdsWithQueuedFrames;
1247
Vishnu Nair802ac4f2023-05-10 13:55:22 -07001248 // Sorted list of layers that were composed during previous frame. This is used to
1249 // avoid an expensive traversal of the layer hierarchy when there are no
1250 // visible region changes. Because this is a list of strong pointers, this will
1251 // extend the life of the layer but this list is only updated in the main thread.
1252 std::vector<sp<Layer>> mPreviouslyComposedLayers;
Dominik Laskowski5d164f22022-07-07 07:56:07 -07001253
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001254 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001255
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001256 struct HotplugEvent {
1257 hal::HWDisplayId hwcDisplayId;
1258 hal::Connection connection = hal::Connection::INVALID;
1259 };
1260
Huihong Luo9ebb7a72023-06-27 17:01:50 -07001261 bool mIsHdcpViaNegVsync = false;
Huihong Luoaac3a772023-09-19 20:51:59 -07001262 bool mIsHotplugErrViaNegVsync = false;
1263
Dominik Laskowskif11728a2022-07-28 13:07:42 -07001264 std::mutex mHotplugMutex;
1265 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mHotplugMutex);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001266
Dominik Laskowskieb627312022-04-07 09:13:16 -07001267 // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
1268 // never removed, so take precedence over external and virtual displays.
1269 //
Dominik Laskowskieb627312022-04-07 09:13:16 -07001270 // May be read from any thread, but must only be written from the main thread.
Dominik Laskowski6b049ff2023-01-29 15:46:45 -05001271 ui::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001272
1273 display::PhysicalDisplays mPhysicalDisplays GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001274
Dominik Laskowskia0858db2024-07-23 16:45:11 -04001275 // The inner or outer display for foldables, while unfolded or folded, respectively.
Dominik Laskowski5c989f52024-04-11 13:57:14 -04001276 std::atomic<PhysicalDisplayId> mActiveDisplayId;
Dominik Laskowskie591b552022-09-09 10:44:56 -07001277
Dominik Laskowski6e465152022-09-28 11:00:25 -04001278 display::DisplayModeController mDisplayModeController;
1279
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001280 struct {
1281 DisplayIdGenerator<GpuVirtualDisplayId> gpu;
1282 std::optional<DisplayIdGenerator<HalVirtualDisplayId>> hal;
1283 } mVirtualDisplayIdGenerators;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +02001284
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07001285 std::atomic_uint mDebugFlashDelay = 0;
1286 std::atomic_bool mDebugDisableHWC = false;
1287 std::atomic_bool mDebugDisableTransformHint = false;
1288 std::atomic<nsecs_t> mDebugInTransaction = 0;
1289 std::atomic_bool mForceFullDamage = false;
1290
Lloyd Pique30db6402023-06-26 18:56:51 +00001291 bool mLayerCachingEnabled = false;
1292 bool mBackpressureGpuComposition = false;
1293
Vishnu Nair81750622023-03-08 15:02:06 -08001294 LayerTracing mLayerTracing;
Dominik Laskowski46471e62022-01-14 15:34:03 -08001295 std::optional<TransactionTracing> mTransactionTracing;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001296
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001297 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001298 const std::unique_ptr<FrameTracer> mFrameTracer;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -07001299 const std::unique_ptr<frametimeline::FrameTimeline> mFrameTimeline;
Dominik Laskowski3dce4f42021-03-08 20:48:28 -08001300
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001301 VsyncId mLastCommittedVsyncId;
Pablo Gamito6be82442022-06-13 11:04:34 +00001302
Lloyd Pique30db6402023-06-26 18:56:51 +00001303 // If blurs should be enabled on this device.
1304 bool mSupportsBlur = false;
1305
Robert Carr9a803c32021-01-14 16:57:58 -08001306 TransactionCallbackInvoker mTransactionCallbackInvoker;
Marissa Walle2ffb422018-10-12 11:33:52 -07001307
chaviweadf0d42019-08-12 13:28:29 -07001308 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001309
Steven Morelanda904bb92019-07-02 17:37:23 -07001310 // to linkToDeath
1311 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001312 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1313 // different threads without a lock and could trigger unsynchronized writes to
1314 // to mWindowManager or mInputFlinger
1315 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001316
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001317 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001318
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001319 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001320
Peiyong Lina3ea5592019-02-10 14:45:00 -08001321 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1322 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1323 // 2. be one of the supported color modes returned by hardware composer, otherwise
1324 // it will not be respected.
1325 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1326 // is not set to 1.
1327 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1328 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1329
Lloyd Pique30db6402023-06-26 18:56:51 +00001330 // Whether to enable wide color gamut (e.g. Display P3) for internal displays that support it.
1331 // If false, wide color modes are filtered out for all internal displays.
1332 bool mSupportsWideColor = false;
Dominik Laskowski788945b2022-08-30 12:10:56 -07001333
Lloyd Pique30db6402023-06-26 18:56:51 +00001334 ui::Dataspace mDefaultCompositionDataspace;
1335 ui::Dataspace mWideColorGamutCompositionDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001336
Patrick Williams0a525a42022-10-26 20:20:50 +00001337 std::unique_ptr<renderengine::RenderEngine> mRenderEngine;
Chavi Weingarten076acac2023-01-19 17:20:43 +00001338 std::atomic<int> mNumTrustedPresentationListeners = 0;
1339
Lloyd Pique70d91362018-10-18 16:02:55 -07001340 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001341
Dominik Laskowskiec0eac22023-01-28 16:16:19 -05001342 CompositionCoveragePerDisplay mCompositionCoverage;
Dominik Laskowski63f12792023-01-21 16:58:22 -05001343
Garfield Tan9c9c1912021-07-19 12:02:16 -07001344 // mMaxRenderTargetSize is only set once in init() so it doesn't need to be protected by
1345 // any mutex.
1346 size_t mMaxRenderTargetSize{1};
Ana Krulec98b5b242018-08-10 15:03:23 -07001347
Lloyd Pique30db6402023-06-26 18:56:51 +00001348 const std::string mHwcServiceName;
1349
Dominik Laskowski068173d2021-08-11 17:22:59 -07001350 std::unique_ptr<scheduler::Scheduler> mScheduler;
Robert Carr720e5062018-07-30 17:45:14 -07001351
Dominik Laskowski80c77272022-07-08 12:47:29 -07001352 scheduler::PresentLatencyTracker mPresentLatencyTracker GUARDED_BY(kMainThreadContext);
Ady Abraham1902d072019-03-01 17:18:59 -08001353
Lloyd Pique30db6402023-06-26 18:56:51 +00001354 bool mLumaSampling = true;
Kevin DuBois413287f2019-02-25 08:46:47 -08001355 sp<RegionSamplingThread> mRegionSamplingThread;
Alec Mouriadebf5c2021-01-05 12:57:36 -08001356 sp<FpsReporter> mFpsReporter;
Galia Peycheva8f04b302021-04-27 13:25:38 +02001357 sp<TunnelModeEnabledReporter> mTunnelModeEnabledReporter;
Lloyd Pique30db6402023-06-26 18:56:51 +00001358 ui::DisplayPrimaries mInternalDisplayPrimaries;
1359
1360 const float mEmulatedDisplayDensity;
1361 const float mInternalDisplayDensity;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001362
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001363 // Should only be accessed by the main thread.
Vishnu Nair03ccbd62021-12-01 17:21:16 -08001364 sp<os::IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001365 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001366
Xiang Wang839fe5b2022-04-04 17:39:38 +00001367 std::unique_ptr<Hwc2::PowerAdvisor> mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001368
Dominik Laskowski02bb2072022-08-26 15:02:52 -07001369 void enableRefreshRateOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
Ady Abraham34392f72019-04-10 11:29:27 -07001370
Sally Qi147581b2023-06-27 11:55:34 -07001371 void enableHdrSdrRatioOverlay(bool enable) REQUIRES(mStateLock, kMainThreadContext);
1372
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001373 // Flag used to set override desired display mode from backdoor
1374 bool mDebugDisplayModeSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001375
Vishnu Nair8eda69e2021-02-26 10:42:10 -08001376 BufferCountTracker mBufferCountTracker;
John Reck88270902021-03-18 11:27:35 -04001377
1378 std::unordered_map<DisplayId, sp<HdrLayerInfoReporter>> mHdrLayerInfoListeners
1379 GUARDED_BY(mStateLock);
John Reck68796592023-01-25 13:47:12 -05001380
Ady Abraham1273ac12021-08-26 17:31:53 -07001381 std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
Ady Abraham562c2712021-05-07 15:10:42 -07001382
Leon Scroggins III85d4b222023-05-09 13:58:18 -04001383 // Must only be accessed on the main thread.
1384 // TODO (b/259407931): Remove.
1385 static ui::Transform::RotationFlags sActiveDisplayRotationFlags;
1386
Ady Abraham1b11bc62021-06-03 19:51:19 -07001387 bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
Dominik Laskowskieb627312022-04-07 09:13:16 -07001388 return hasDisplay(
1389 [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
Ady Abraham1b11bc62021-06-03 19:51:19 -07001390 }
Sally Qi147581b2023-06-27 11:55:34 -07001391 bool isHdrSdrRatioOverlayEnabled() const REQUIRES(mStateLock) {
1392 return hasDisplay(
1393 [](const auto& display) { return display.isHdrSdrRatioOverlayEnabled(); });
1394 }
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001395 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nairc5a5b6e2023-02-28 00:19:07 +00001396 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1397 std::function<bool(const frontend::LayerSnapshot&, bool& outStopTraversal)>
1398 snapshotFilterFn);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001399 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Ajinkya Chalke02844632023-03-01 12:10:14 +00001400 std::optional<ui::LayerStack> layerStack, uint32_t uid,
1401 std::unordered_set<uint32_t> excludeLayerIds);
1402 std::function<std::vector<std::pair<Layer*, sp<LayerFE>>>()> getLayerSnapshotsForScreenshots(
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001403 uint32_t rootLayerId, uint32_t uid, std::unordered_set<uint32_t> excludeLayerIds,
Vishnu Nair36d5f8e2023-03-19 13:31:35 -07001404 bool childrenOnly, const std::optional<FloatRect>& optionalParentCrop);
Ady Abraham1b11bc62021-06-03 19:51:19 -07001405
chaviw60c9d3e2021-06-04 12:52:17 -05001406 const sp<WindowInfosListenerInvoker> mWindowInfosListenerInvoker;
rnleea2ecd832021-07-29 13:58:30 -07001407
Nathaniel Nifong1303d912021-10-06 09:41:24 -04001408 // returns the framerate of the layer with the given sequence ID
1409 float getLayerFramerate(nsecs_t now, int32_t id) const {
1410 return mScheduler->getLayerFramerate(now, id);
1411 }
Matt Buckleyef51fba2021-10-12 19:30:12 +00001412
Matt Buckley50c44062022-01-17 20:48:10 +00001413 bool mPowerHintSessionEnabled;
Robert Horvathdce110a2022-09-16 11:08:47 +02001414 // Whether a display should be turned on when initialized
1415 bool mSkipPowerOnForQuiescent;
Lloyd Pique30db6402023-06-26 18:56:51 +00001416
Vishnu Nair7be27602024-03-28 20:27:09 -07001417 frontend::LayerLifecycleManager mLayerLifecycleManager GUARDED_BY(kMainThreadContext);
1418 frontend::LayerHierarchyBuilder mLayerHierarchyBuilder GUARDED_BY(kMainThreadContext);
1419 frontend::LayerSnapshotBuilder mLayerSnapshotBuilder GUARDED_BY(kMainThreadContext);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001420
Vishnu Naira12c5c72024-08-28 15:42:17 -07001421 mutable std::mutex mCreatedLayersLock;
1422 std::vector<sp<Layer>> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
Vishnu Nair7be27602024-03-28 20:27:09 -07001423 std::vector<std::pair<uint32_t, std::string>> mDestroyedHandles GUARDED_BY(mCreatedLayersLock);
1424 std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers
1425 GUARDED_BY(mCreatedLayersLock);
1426 std::vector<LayerCreationArgs> mNewLayerArgs GUARDED_BY(mCreatedLayersLock);
Vishnu Nair3af0ec02023-02-10 04:13:48 +00001427 // These classes do not store any client state but help with managing transaction callbacks
1428 // and stats.
Vishnu Nair7be27602024-03-28 20:27:09 -07001429 std::unordered_map<uint32_t, sp<Layer>> mLegacyLayers GUARDED_BY(kMainThreadContext);
Ady Abrahame9ebce02022-02-03 12:05:06 -08001430
Vishnu Nair7be27602024-03-28 20:27:09 -07001431 TransactionHandler mTransactionHandler GUARDED_BY(kMainThreadContext);
1432 ui::DisplayMap<ui::LayerStack, frontend::DisplayInfo> mFrontEndDisplayInfos
1433 GUARDED_BY(kMainThreadContext);
1434 bool mFrontEndDisplayInfosChanged GUARDED_BY(kMainThreadContext) = false;
Patrick Williams1caf3b72023-03-31 10:59:10 -05001435
Patrick Williamsd86bd8c2023-04-21 11:54:11 -05001436 // WindowInfo ids visible during the last commit.
Vishnu Nair7be27602024-03-28 20:27:09 -07001437 std::unordered_set<int32_t> mVisibleWindowIds GUARDED_BY(kMainThreadContext);
Brian Johnson51d8d5d2023-07-28 10:18:47 -07001438
1439 // Mirroring
1440 // Map of displayid to mirrorRoot
1441 ftl::SmallMap<int64_t, sp<SurfaceControl>, 3> mMirrorMapForDebug;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001442
ramindanic67d22c2023-11-28 14:58:47 -08001443 // NotifyExpectedPresentHint
ramindaniae645822024-01-11 10:57:29 -08001444 enum class NotifyExpectedPresentHintStatus {
1445 // Represents that framework can start sending hint if required.
1446 Start,
1447 // Represents that the hint is already sent.
1448 Sent,
1449 // Represents that the hint will be scheduled with a new frame.
1450 ScheduleOnPresent,
1451 // Represents that a hint will be sent instantly by scheduling on the main thread.
1452 ScheduleOnTx
1453 };
ramindanic67d22c2023-11-28 14:58:47 -08001454 struct NotifyExpectedPresentData {
ramindaniae645822024-01-11 10:57:29 -08001455 TimePoint lastExpectedPresentTimestamp{};
ramindanic67d22c2023-11-28 14:58:47 -08001456 Fps lastFrameInterval{};
ramindaniae645822024-01-11 10:57:29 -08001457 // hintStatus is read and write from multiple threads such as
1458 // main thread, EventThread. And is atomic for that reason.
1459 std::atomic<NotifyExpectedPresentHintStatus> hintStatus =
1460 NotifyExpectedPresentHintStatus::Start;
ramindanic67d22c2023-11-28 14:58:47 -08001461 };
1462 std::unordered_map<PhysicalDisplayId, NotifyExpectedPresentData> mNotifyExpectedPresentMap;
ramindaniae645822024-01-11 10:57:29 -08001463 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) override
1464 REQUIRES(kMainThreadContext);
ramindani32a88b12024-01-31 18:45:30 -08001465 void scheduleNotifyExpectedPresentHint(PhysicalDisplayId displayId,
1466 VsyncId vsyncId = VsyncId{
1467 FrameTimelineInfo::INVALID_VSYNC_ID});
ramindanic67d22c2023-11-28 14:58:47 -08001468 void notifyExpectedPresentIfRequired(PhysicalDisplayId, Period vsyncPeriod,
1469 TimePoint expectedPresentTime, Fps frameInterval,
1470 std::optional<Period> timeoutOpt);
1471
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001472 void sfdo_enableRefreshRateOverlay(bool active);
1473 void sfdo_setDebugFlash(int delay);
1474 void sfdo_scheduleComposite();
1475 void sfdo_scheduleCommit();
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001476 void sfdo_forceClientComposition(bool enabled);
Huihong Luof5029222021-12-16 14:33:46 -08001477};
1478
1479class SurfaceComposerAIDL : public gui::BnSurfaceComposer {
1480public:
Alan Dingfc6eab52024-05-02 18:28:45 -07001481 explicit SurfaceComposerAIDL(sp<SurfaceFlinger> sf) : mFlinger(std::move(sf)) {}
Huihong Luof5029222021-12-16 14:33:46 -08001482
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001483 binder::Status bootFinished() override;
1484 binder::Status createDisplayEventConnection(
1485 VsyncSource vsyncSource, EventRegistration eventRegistration,
Rachel Lee2248f522023-01-27 16:45:23 -08001486 const sp<IBinder>& layerHandle,
Huihong Luo1b0c49f2022-03-15 19:18:21 -07001487 sp<gui::IDisplayEventConnection>* outConnection) override;
Huihong Luod3d8f8e2022-03-08 14:48:46 -08001488 binder::Status createConnection(sp<gui::ISurfaceComposerClient>* outClient) override;
Alan Dingd53801c2024-05-08 16:45:29 -07001489 binder::Status createVirtualDisplay(const std::string& displayName, bool isSecure,
1490 const std::string& uniqueId, float requestedRefreshRate,
1491 sp<IBinder>* outDisplay) override;
1492 binder::Status destroyVirtualDisplay(const sp<IBinder>& displayToken) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001493 binder::Status getPhysicalDisplayIds(std::vector<int64_t>* outDisplayIds) override;
Huihong Luo07e72362022-02-14 14:26:04 -08001494 binder::Status getPhysicalDisplayToken(int64_t displayId, sp<IBinder>* outDisplay) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001495 binder::Status setPowerMode(const sp<IBinder>& display, int mode) override;
Huihong Luo0a81aa32022-02-22 16:02:36 -08001496 binder::Status getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) override;
Huihong Luoaa7fc2e2022-02-15 10:43:00 -08001497 binder::Status getDisplayStats(const sp<IBinder>& display,
1498 gui::DisplayStatInfo* outStatInfo) override;
1499 binder::Status getDisplayState(const sp<IBinder>& display,
1500 gui::DisplayState* outState) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001501 binder::Status getStaticDisplayInfo(int64_t displayId,
Huihong Luoa79ddf42022-02-17 00:01:38 -08001502 gui::StaticDisplayInfo* outInfo) override;
Sally Qi6bb12822022-10-05 11:42:30 -07001503 binder::Status getDynamicDisplayInfoFromId(int64_t displayId,
1504 gui::DynamicDisplayInfo* outInfo) override;
1505 binder::Status getDynamicDisplayInfoFromToken(const sp<IBinder>& display,
1506 gui::DynamicDisplayInfo* outInfo) override;
Huihong Luoca3d9a42022-02-22 11:07:34 -08001507 binder::Status getDisplayNativePrimaries(const sp<IBinder>& display,
1508 gui::DisplayPrimaries* outPrimaries) override;
1509 binder::Status setActiveColorMode(const sp<IBinder>& display, int colorMode) override;
1510 binder::Status setBootDisplayMode(const sp<IBinder>& display, int displayModeId) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001511 binder::Status clearBootDisplayMode(const sp<IBinder>& display) override;
1512 binder::Status getBootDisplayModeSupport(bool* outMode) override;
Sally Qi0cbd08b2022-08-17 12:12:28 -07001513 binder::Status getOverlaySupport(gui::OverlayProperties* outProperties) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001514 binder::Status getHdrConversionCapabilities(
1515 std::vector<gui::HdrConversionCapability>*) override;
Kriti Dangd432bb52023-02-09 18:21:04 +01001516 binder::Status setHdrConversionStrategy(const gui::HdrConversionStrategy& hdrConversionStrategy,
1517 int32_t*) override;
Kriti Dang674b9372022-11-18 10:58:44 +01001518 binder::Status getHdrOutputConversionSupport(bool* outSupport) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001519 binder::Status setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override;
1520 binder::Status setGameContentType(const sp<IBinder>& display, bool on) override;
Huihong Luof5029222021-12-16 14:33:46 -08001521 binder::Status captureDisplay(const DisplayCaptureArgs&,
1522 const sp<IScreenCaptureListener>&) override;
John Reck7e4c4872023-11-14 18:31:03 -05001523 binder::Status captureDisplayById(int64_t, const CaptureArgs&,
1524 const sp<IScreenCaptureListener>&) override;
Huihong Luof5029222021-12-16 14:33:46 -08001525 binder::Status captureLayers(const LayerCaptureArgs&,
1526 const sp<IScreenCaptureListener>&) override;
Chavi Weingartenf6fb4452024-01-23 21:10:30 +00001527 binder::Status captureLayersSync(const LayerCaptureArgs&, ScreenCaptureResults* results);
Dominik Laskowski66296b22022-07-12 08:20:36 -07001528
1529 // TODO(b/239076119): Remove deprecated AIDL.
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001530 [[deprecated]] binder::Status clearAnimationFrameStats() override {
1531 return binder::Status::ok();
1532 }
Dominik Laskowski66296b22022-07-12 08:20:36 -07001533 [[deprecated]] binder::Status getAnimationFrameStats(gui::FrameStats*) override {
Dominik Laskowskif84183b2022-07-25 14:02:10 -07001534 return binder::Status::ok();
Dominik Laskowski66296b22022-07-12 08:20:36 -07001535 }
1536
Huihong Luo05539a12022-02-23 10:29:40 -08001537 binder::Status overrideHdrTypes(const sp<IBinder>& display,
1538 const std::vector<int32_t>& hdrTypes) override;
1539 binder::Status onPullAtom(int32_t atomId, gui::PullAtomData* outPullData) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001540 binder::Status getCompositionPreference(gui::CompositionPreference* outPref) override;
1541 binder::Status getDisplayedContentSamplingAttributes(
1542 const sp<IBinder>& display, gui::ContentSamplingAttributes* outAttrs) override;
1543 binder::Status setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
1544 int8_t componentMask,
1545 int64_t maxFrames) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001546 binder::Status getDisplayedContentSample(const sp<IBinder>& display, int64_t maxFrames,
1547 int64_t timestamp,
1548 gui::DisplayedFrameStats* outStats) override;
Huihong Luo05539a12022-02-23 10:29:40 -08001549 binder::Status getProtectedContentSupport(bool* outSupporte) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001550 binder::Status isWideColorDisplay(const sp<IBinder>& token,
1551 bool* outIsWideColorDisplay) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001552 binder::Status addRegionSamplingListener(
1553 const gui::ARect& samplingArea, const sp<IBinder>& stopLayerHandle,
1554 const sp<gui::IRegionSamplingListener>& listener) override;
1555 binder::Status removeRegionSamplingListener(
1556 const sp<gui::IRegionSamplingListener>& listener) override;
1557 binder::Status addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) override;
1558 binder::Status removeFpsListener(const sp<gui::IFpsListener>& listener) override;
1559 binder::Status addTunnelModeEnabledListener(
1560 const sp<gui::ITunnelModeEnabledListener>& listener) override;
1561 binder::Status removeTunnelModeEnabledListener(
1562 const sp<gui::ITunnelModeEnabledListener>& listener) override;
Ady Abraham285f8c12022-10-11 17:12:14 -07001563 binder::Status setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1564 const gui::DisplayModeSpecs&) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001565 binder::Status getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
1566 gui::DisplayModeSpecs* outSpecs) override;
Huihong Luo37396db2022-02-15 10:43:00 -08001567 binder::Status getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1568 bool* outSupport) override;
1569 binder::Status setDisplayBrightness(const sp<IBinder>& displayToken,
1570 const gui::DisplayBrightness& brightness) override;
1571 binder::Status addHdrLayerInfoListener(const sp<IBinder>& displayToken,
1572 const sp<gui::IHdrLayerInfoListener>& listener) override;
1573 binder::Status removeHdrLayerInfoListener(
1574 const sp<IBinder>& displayToken,
1575 const sp<gui::IHdrLayerInfoListener>& listener) override;
John Reck68796592023-01-25 13:47:12 -05001576
Huihong Luo37396db2022-02-15 10:43:00 -08001577 binder::Status notifyPowerBoost(int boostId) override;
Huihong Luo3bdef862022-03-03 11:57:19 -08001578 binder::Status setGlobalShadowSettings(const gui::Color& ambientColor,
1579 const gui::Color& spotColor, float lightPosY,
1580 float lightPosZ, float lightRadius) override;
1581 binder::Status getDisplayDecorationSupport(
1582 const sp<IBinder>& displayToken,
1583 std::optional<gui::DisplayDecorationSupport>* outSupport) override;
Andy Yu8c2703d2023-11-03 11:22:46 -07001584 binder::Status setGameModeFrameRateOverride(int32_t uid, float frameRate) override;
1585 binder::Status setGameDefaultFrameRateOverride(int32_t uid, float frameRate) override;
Carlos Martinez Romero5ec086e2023-02-14 00:44:36 +00001586 binder::Status enableRefreshRateOverlay(bool active) override;
1587 binder::Status setDebugFlash(int delay) override;
1588 binder::Status scheduleComposite() override;
1589 binder::Status scheduleCommit() override;
Carlos Martinez Romerob4ea9e62023-10-25 21:48:56 +00001590 binder::Status forceClientComposition(bool enabled) override;
Tony Huangf3621102023-09-04 17:14:22 +08001591 binder::Status updateSmallAreaDetection(const std::vector<int32_t>& appIds,
Tony Huang9ac5e6e2023-08-24 09:01:44 +00001592 const std::vector<float>& thresholds) override;
Tony Huangf3621102023-09-04 17:14:22 +08001593 binder::Status setSmallAreaDetectionThreshold(int32_t appId, float threshold) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001594 binder::Status getGpuContextPriority(int32_t* outPriority) override;
1595 binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
Patrick Williamsacd22582023-07-12 13:47:28 -05001596 binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
1597 gui::WindowInfosListenerInfo* outInfo) override;
Huihong Luo02186fb2022-02-23 14:21:54 -08001598 binder::Status removeWindowInfosListener(
1599 const sp<gui::IWindowInfosListener>& windowInfosListener) override;
Ady Abraham07d03c42023-09-27 19:15:08 -07001600 binder::Status getStalledTransactionInfo(
1601 int pid, std::optional<gui::StalledTransactionInfo>* outInfo) override;
1602 binder::Status getSchedulingPolicy(gui::SchedulingPolicy* outPolicy) override;
Wenhui Yangeafc18a2024-05-14 17:15:52 +00001603 binder::Status notifyShutdown() override;
Pascal Mütschardd56514e2024-05-24 17:37:13 +02001604 binder::Status addJankListener(const sp<IBinder>& layer,
1605 const sp<gui::IJankListener>& listener) override;
1606 binder::Status flushJankData(int32_t layerId) override;
1607 binder::Status removeJankListener(int32_t layerId, const sp<gui::IJankListener>& listener,
1608 int64_t afterVsync) override;
Huihong Luof5029222021-12-16 14:33:46 -08001609
1610private:
Huihong Luo07e72362022-02-14 14:26:04 -08001611 static const constexpr bool kUsePermissionCache = true;
1612 status_t checkAccessPermission(bool usePermissionCache = kUsePermissionCache);
Huihong Luo37396db2022-02-15 10:43:00 -08001613 status_t checkControlDisplayBrightnessPermission();
Huihong Luo02186fb2022-02-23 14:21:54 -08001614 status_t checkReadFrameBufferPermission();
Sally Qi6bb12822022-10-05 11:42:30 -07001615 static void getDynamicDisplayInfoInternal(ui::DynamicDisplayInfo& info,
1616 gui::DynamicDisplayInfo*& outInfo);
Huihong Luo07e72362022-02-14 14:26:04 -08001617
1618private:
Alan Dingfc6eab52024-05-02 18:28:45 -07001619 const sp<SurfaceFlinger> mFlinger;
Romain Guy0147a172017-06-01 13:53:56 -07001620};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001621
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001622} // namespace android