blob: a1b9b146471f54a0f9fe910e52d8de67e31bd420 [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 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Dominik Laskowski9dab3432019-03-27 13:21:10 -070017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080019#include <sys/types.h>
20
Mathias Agopian3f844832013-08-07 21:24:32 -070021/*
22 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
23 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070024
Dominik Laskowski83b88212018-12-11 13:34:06 -080025#include <android-base/thread_annotations.h>
Lloyd Pique6a3b4462019-03-07 20:58:12 -080026#include <compositionengine/OutputColorSetting.h>
Steven Moreland2716e112018-02-23 14:57:20 -080027#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080028#include <cutils/compiler.h>
29#include <gui/BufferQueue.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080030#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080031#include <gui/ISurfaceComposer.h>
32#include <gui/ISurfaceComposerClient.h>
Valerie Hau5de3ad22019-08-20 07:47:43 -070033#include <gui/ITransactionCompletedListener.h>
Robert Carr4cdc58f2017-08-23 14:22:20 -070034#include <gui/LayerState.h>
Dan Stozae77c7662016-05-13 11:37:28 -070035#include <gui/OccupancyTracker.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080036#include <layerproto/LayerProtoHeader.h>
37#include <math/mat4.h>
Vishnu Nair08f6eae2019-11-26 14:01:39 -080038#include <renderengine/LayerSettings.h>
Vishnu Nair35798872017-10-06 16:00:36 -070039#include <serviceutils/PriorityDumper.h>
Michael Wright28f24d02016-07-12 13:30:53 -070040#include <system/graphics.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080041#include <ui/FenceTime.h>
42#include <ui/PixelFormat.h>
Brian Lindahla13f2d52020-03-05 11:54:17 +010043#include <ui/Size.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080044#include <utils/Errors.h>
45#include <utils/KeyedVector.h>
46#include <utils/RefBase.h>
47#include <utils/SortedVector.h>
48#include <utils/Trace.h>
49#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070050
Marissa Wall947d34e2019-03-29 14:03:53 -070051#include "ClientCache.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070052#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080053#include "DisplayHardware/HWC2.h"
Peiyong Lin74ca2f42019-01-14 19:36:57 -080054#include "DisplayHardware/PowerAdvisor.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080055#include "Effects/Daltonizer.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080056#include "FrameTracker.h"
Robert Carr2047fae2016-11-28 14:09:09 -080057#include "LayerVector.h"
Dominik Laskowskiccf37d72019-02-01 16:47:58 -080058#include "Scheduler/RefreshRateConfigs.h"
Ana Krulecb43429d2019-01-09 14:28:51 -080059#include "Scheduler/RefreshRateStats.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070060#include "Scheduler/Scheduler.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070061#include "Scheduler/VSyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080062#include "SurfaceFlingerFactory.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080063#include "SurfaceTracing.h"
Ady Abraham50204dd2019-07-19 15:47:11 -070064#include "TracedOrdinal.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080065#include "TransactionCompletedThread.h"
Mathias Agopian86303202012-07-24 22:46:10 -070066
Dominik Laskowski83b88212018-12-11 13:34:06 -080067#include <atomic>
68#include <cstdint>
Dominik Laskowskic2867142019-01-21 11:33:38 -080069#include <functional>
Dominik Laskowskidd4ef272020-04-23 14:02:12 -070070#include <future>
Dan Stozae77c7662016-05-13 11:37:28 -070071#include <map>
Dominik Laskowski83b88212018-12-11 13:34:06 -080072#include <memory>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080073#include <mutex>
Dominik Laskowskieddeda12019-07-19 11:54:13 -070074#include <optional>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080075#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070076#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070077#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070078#include <thread>
Dominik Laskowskic2867142019-01-21 11:33:38 -080079#include <type_traits>
Dominik Laskowski075d3172018-05-24 15:50:06 -070080#include <unordered_map>
Dominik Laskowski22488f62019-03-28 09:53:04 -070081#include <unordered_set>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080082#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070083
chaviw1d044282017-09-27 12:19:28 -070084using namespace android::surfaceflinger;
85
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080086namespace android {
87
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080088class Client;
Lloyd Pique144e1162017-12-20 16:44:52 -080089class EventThread;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070090class HWComposer;
Chris Ye0783e992020-06-02 21:34:49 -070091struct SetInputWindowsListener;
Lloyd Pique12eb4232018-01-17 11:54:43 -080092class IGraphicBufferProducer;
Lloyd Pique144e1162017-12-20 16:44:52 -080093class Layer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070094class MessageBase;
Ady Abraham03b02dd2019-03-21 15:40:11 -070095class RefreshRateOverlay;
Dominik Laskowski9dab3432019-03-27 13:21:10 -070096class RegionSamplingThread;
Marin Shalamanovf6b5d182020-06-12 02:08:51 +020097class RenderArea;
Yiwei Zhang7e666a52018-11-15 13:33:42 -080098class TimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -070099class FrameTracer;
Lloyd Pique144e1162017-12-20 16:44:52 -0800100
Chris Ye0783e992020-06-02 21:34:49 -0700101namespace os {
102 class IInputFlinger;
103}
104
Lloyd Pique542307f2018-10-19 13:24:08 -0700105namespace compositionengine {
106class DisplaySurface;
Lloyd Pique26d03fd2019-03-07 21:23:23 -0800107class OutputLayer;
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800108
109struct CompositionRefreshArgs;
Lloyd Pique542307f2018-10-19 13:24:08 -0700110} // namespace compositionengine
111
Peiyong Lin833074a2018-08-28 11:53:54 -0700112namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800113class RenderEngine;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700114} // namespace renderengine
chaviwa76b2712017-09-20 12:02:26 -0700115
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800116namespace dvr {
117class VrFlinger;
118} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800119
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800120enum {
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700121 eTransactionNeeded = 0x01,
122 eTraversalNeeded = 0x02,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700123 eDisplayTransactionNeeded = 0x04,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700124 eTransformHintUpdateNeeded = 0x08,
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700125 eTransactionFlushNeeded = 0x10,
126 eTransactionMask = 0x1f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800127};
128
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800129using DisplayColorSetting = compositionengine::OutputColorSetting;
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800130
David Sodman105b7dc2017-11-04 20:28:14 -0700131class SurfaceFlingerBE
132{
133public:
134 SurfaceFlingerBE();
135
David Sodmanbc815282017-11-05 18:57:52 -0800136 const std::string mHwcServiceName; // "default" for real use, something else for testing.
137
David Sodman73beded2017-11-15 11:56:06 -0800138 FenceTimeline mGlCompositionDoneTimeline;
139 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800140
David Sodman99974d22017-11-28 12:04:33 -0800141 // protected by mCompositorTimingLock;
142 mutable std::mutex mCompositorTimingLock;
143 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800144
David Sodman99974d22017-11-28 12:04:33 -0800145 // Only accessed from the main thread.
146 struct CompositePresentTime {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700147 nsecs_t composite = -1;
148 std::shared_ptr<FenceTime> display = FenceTime::NO_FENCE;
David Sodman99974d22017-11-28 12:04:33 -0800149 };
150 std::queue<CompositePresentTime> mCompositePresentTimes;
151
David Sodman4a36e932017-11-07 14:29:47 -0800152 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700153 nsecs_t mFrameBuckets[NUM_BUCKETS] = {};
154 nsecs_t mTotalTime = 0;
155 std::atomic<nsecs_t> mLastSwapTime = 0;
David Sodman4a36e932017-11-07 14:29:47 -0800156
David Sodmancbaf0832017-11-07 14:21:36 -0800157 // Double- vs. triple-buffering stats
158 struct BufferingStats {
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700159 size_t numSegments = 0;
160 nsecs_t totalTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800161
162 // "Two buffer" means that a third buffer was never used, whereas
163 // "double-buffered" means that on average the segment only used two
164 // buffers (though it may have used a third for some part of the
165 // segment)
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700166 nsecs_t twoBufferTime = 0;
167 nsecs_t doubleBufferedTime = 0;
168 nsecs_t tripleBufferedTime = 0;
David Sodmancbaf0832017-11-07 14:21:36 -0800169 };
170 mutable Mutex mBufferingStatsMutex;
171 std::unordered_map<std::string, BufferingStats> mBufferingStats;
172
David Sodman105b7dc2017-11-04 20:28:14 -0700173 // The composer sequence id is a monotonically increasing integer that we
174 // use to differentiate callbacks from different hardware composer
175 // instances. Each hardware composer instance gets a different sequence id.
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700176 int32_t mComposerSequenceId = 0;
chaviw291d88a2019-02-14 10:33:58 -0800177};
David Sodman105b7dc2017-11-04 20:28:14 -0700178
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700179class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700180 public PriorityDumper,
Alec Mouri4545a8a2019-08-08 20:05:32 -0700181 public ClientCache::ErasedRecipient,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700182 private IBinder::DeathRecipient,
Ady Abraham2139f732019-11-13 18:56:40 -0800183 private HWC2::ComposerCallback,
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800184 private ISchedulerCallback {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800185public:
David Sodman105b7dc2017-11-04 20:28:14 -0700186 SurfaceFlingerBE& getBE() { return mBE; }
187 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800188
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800189 // This is the phase offset in nanoseconds of the software vsync event
190 // relative to the vsync event reported by HWComposer. The software vsync
191 // event is when SurfaceFlinger and Choreographer-based applications run each
192 // frame.
193 //
194 // This phase offset allows adjustment of the minimum latency from application
195 // wake-up time (by Choreographer) to the time at which the resulting window
196 // image is displayed. This value may be either positive (after the HW vsync)
197 // or negative (before the HW vsync). Setting it to 0 will result in a lower
198 // latency bound of two vsync periods because the app and SurfaceFlinger
199 // will run just after the HW vsync. Setting it to a positive number will
200 // result in the minimum latency being:
201 //
202 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
203 //
204 // Note that reducing this latency makes it more likely for the applications
205 // to not have their window content image ready in time. When this happens
206 // the latency will end up being an additional vsync period, and animations
207 // will hiccup. Therefore, this latency should be tuned somewhat
208 // conservatively (or at least with awareness of the trade-off being made).
209 static int64_t vsyncPhaseOffsetNs;
210 static int64_t sfVsyncPhaseOffsetNs;
211
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800212 // If fences from sync Framework are supported.
213 static bool hasSyncFramework;
214
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700215 // The offset in nanoseconds to use when DispSync timestamps present fence
216 // signaling time.
217 static int64_t dispSyncPresentTimeOffset;
218
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700219 // Some hardware can do RGB->YUV conversion more efficiently in hardware
220 // controlled by HWC than in hardware controlled by the video encoder.
221 // This instruct VirtualDisplaySurface to use HWC for such conversion on
222 // GL composition.
223 static bool useHwcForRgbToYuv;
224
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800225 // Maximum dimension supported by HWC for virtual display.
226 // Equal to min(max_height, max_width).
227 static uint64_t maxVirtualDisplaySize;
228
Fabien Sanglard1971b632017-03-10 14:50:03 -0800229 // Controls the number of buffers SurfaceFlinger will allocate for use in
230 // FramebufferSurface
231 static int64_t maxFrameBufferAcquiredBuffers;
232
Brian Lindahla13f2d52020-03-05 11:54:17 +0100233 // Controls the maximum width and height in pixels that the graphics pipeline can support for
234 // GPU fallback composition. For example, 8k devices with 4k GPUs, or 4k devices with 2k GPUs.
235 static uint32_t maxGraphicsWidth;
236 static uint32_t maxGraphicsHeight;
237
Peiyong Lin13effd12018-07-24 17:01:47 -0700238 // Indicate if a device has wide color gamut display. This is typically
239 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600240 static bool hasWideColorDisplay;
241
Dominik Laskowski718f9602019-11-09 20:01:35 -0800242 static ui::Rotation internalDisplayOrientation;
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700243
Peiyong Lin13effd12018-07-24 17:01:47 -0700244 // Indicate if device wants color management on its display.
245 static bool useColorManagement;
246
Peiyong Linb3839ad2018-09-05 15:37:19 -0700247 static bool useContextPriority;
248
Peiyong Lin0256f722018-08-31 15:45:10 -0700249 // The data space and pixel format that SurfaceFlinger expects hardware composer
250 // to composite efficiently. Meaning under most scenarios, hardware composer
251 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700252 static ui::Dataspace defaultCompositionDataspace;
253 static ui::PixelFormat defaultCompositionPixelFormat;
254
255 // The data space and pixel format that SurfaceFlinger expects hardware composer
256 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
257 // hardware composer will accept layers with the data space and pixel format.
258 static ui::Dataspace wideColorGamutCompositionDataspace;
259 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700260
Ana Krulec3803b8d2020-02-03 16:35:46 -0800261 // Whether to use frame rate API when deciding about the refresh rate of the display. This
262 // variable is caches in SF, so that we can check it with each layer creation, and a void the
263 // overhead that is caused by reading from sysprop.
264 static bool useFrameRateApi;
265
Martin Liu4a322352020-03-24 21:30:38 +0800266 // set main thread scheduling policy
267 static status_t setSchedFifo(bool enabled) ANDROID_API;
268
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700269 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700270 return "SurfaceFlinger";
271 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800272
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800273 struct SkipInitializationTag {};
274 static constexpr SkipInitializationTag SkipInitialization;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700275 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
276 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800277
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700278 // must be called before clients can connect
279 void init() ANDROID_API;
280
281 // starts SurfaceFlinger main loop in the current thread
282 void run() ANDROID_API;
283
Dominik Laskowskidd4ef272020-04-23 14:02:12 -0700284 // Schedule an asynchronous or synchronous task on the main thread.
285 template <typename F, typename T = std::invoke_result_t<F>>
286 [[nodiscard]] std::future<T> schedule(F&&);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800287
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700288 // force full composition on all displays
289 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800290
Lloyd Pique90c115d2018-09-18 21:39:42 -0700291 surfaceflinger::Factory& getFactory() { return mFactory; }
292
Lloyd Pique70d91362018-10-18 16:02:55 -0700293 // The CompositionEngine encapsulates all composition related interfaces and actions.
294 compositionengine::CompositionEngine& getCompositionEngine() const;
295
Dan Stoza436ccf32018-06-21 12:10:12 -0700296 // Obtains a name from the texture pool, or, if the pool is empty, posts a
297 // synchronous message to the main thread to obtain one on the fly
298 uint32_t getNewTexture();
299
Mathias Agopian86303202012-07-24 22:46:10 -0700300 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700301 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700302
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700303 // called on the main thread by MessageQueue when an internal message
304 // is received
305 // TODO: this should be made accessible only to MessageQueue
Ady Abraham5facfb12020-04-22 15:18:31 -0700306 void onMessageReceived(int32_t what, nsecs_t expectedVSyncTime);
Mathias Agopian3094df32012-06-18 18:06:45 -0700307
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700308 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700309
Robert Carr0d480722017-01-10 16:42:54 -0800310 bool authenticateSurfaceTextureLocked(
311 const sp<IGraphicBufferProducer>& bufferProducer) const;
312
Dominik Laskowski75848362019-11-11 17:57:20 -0800313 void onLayerFirstRef(Layer*);
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700314 void onLayerDestroyed(Layer*);
Robert Carr2e102c92018-10-23 12:11:15 -0700315
Valerie Hauc5686802019-11-22 14:18:09 -0800316 void removeFromOffscreenLayers(Layer* layer);
317
Marissa Walle2ffb422018-10-12 11:33:52 -0700318 TransactionCompletedThread& getTransactionCompletedThread() {
319 return mTransactionCompletedThread;
320 }
321
Alec Mouri9a02eda2020-04-21 17:39:34 -0700322 // Converts from a binder handle to a Layer
323 // Returns nullptr if the handle does not point to an existing layer.
324 // Otherwise, returns a weak reference so that callers off the main-thread
325 // won't accidentally hold onto the last strong reference.
326 wp<Layer> fromHandle(const sp<IBinder>& handle);
327 wp<Layer> fromHandleLocked(const sp<IBinder>& handle) REQUIRES(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -0700328
Alec Mouri4545a8a2019-08-08 20:05:32 -0700329 // Inherit from ClientCache::ErasedRecipient
330 void bufferErased(const client_cache_t& clientCacheId) override;
331
Vishnu Nair9b079a22020-01-21 14:36:08 -0800332 // If set, disables reusing client composition buffers. This can be set by
333 // debug.sf.disable_client_composition_cache
334 bool mDisableClientCompositionCache = false;
Chris Ye0783e992020-06-02 21:34:49 -0700335 void setInputWindowsFinished();
Vishnu Nair9b079a22020-01-21 14:36:08 -0800336
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700337private:
David Sodman0c69cad2017-08-21 12:12:51 -0700338 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700339 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700340 friend class BufferStateLayer;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700341 friend class Client;
342 friend class Layer;
Dan Stozab9b08832014-03-13 11:55:57 -0700343 friend class MonitoredProducer;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700344 friend class RefreshRateOverlay;
Dan Stozaec460082018-12-17 15:35:09 -0800345 friend class RegionSamplingThread;
Nataniel Borges2b796da2019-02-15 13:32:18 -0800346 friend class SurfaceTracing;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800347
Lloyd Piquef58625d2017-12-19 13:22:33 -0800348 // For unit tests
349 friend class TestableSurfaceFlinger;
Valerie Haud251afb2019-03-29 14:19:02 -0700350 friend class TransactionApplicationTest;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800351
Jamie Gennis6547ff42013-07-16 20:12:42 -0700352 // This value is specified in number of frames. Log frame stats at most
353 // every half hour.
354 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
355
Nataniel Borges2b796da2019-02-15 13:32:18 -0800356 static const int MAX_TRACING_MEMORY = 100 * 1024 * 1024; // 100MB
Dan Stoza7d89d062015-04-30 13:29:25 -0700357
Lloyd Pique58e24a32019-08-01 15:50:14 -0700358protected:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700359 // We're reference counted, never destroy SurfaceFlinger directly
360 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800361
Lloyd Pique58e24a32019-08-01 15:50:14 -0700362private:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700363 /* ------------------------------------------------------------------------
364 * Internal data structures
365 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800366
Robert Carr2047fae2016-11-28 14:09:09 -0800367 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800368 public:
chaviwfd462612018-05-31 16:11:27 -0700369 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700370 State& operator=(const State& other) {
371 // We explicitly don't copy stateSet so that, e.g., mDrawingState
372 // always uses the Drawing StateSet.
373 layersSortedByZ = other.layersSortedByZ;
374 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700375 colorMatrixChanged = other.colorMatrixChanged;
376 if (colorMatrixChanged) {
377 colorMatrix = other.colorMatrix;
378 }
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800379 globalShadowSettings = other.globalShadowSettings;
380
Dan Stoza412903f2017-04-27 13:42:17 -0700381 return *this;
382 }
383
384 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700385 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700386 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800387
Chia-I Wu28f320b2018-05-03 11:02:56 -0700388 bool colorMatrixChanged = true;
389 mat4 colorMatrix;
390
Vishnu Nair08f6eae2019-11-26 14:01:39 -0800391 renderengine::ShadowSettings globalShadowSettings;
392
Edgar Arriaga844fa672020-01-16 14:21:42 -0800393 void traverse(const LayerVector::Visitor& visitor) const;
Dan Stoza412903f2017-04-27 13:42:17 -0700394 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
395 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800396 };
397
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700398 /* ------------------------------------------------------------------------
399 * IBinder interface
400 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800401 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
402 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
Steven Thomasd4071902020-03-24 16:02:53 -0700403 bool callingThreadHasUnscopedSurfaceFlingerAccess(bool usePermissionCache = true)
404 EXCLUDES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800405
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700406 /* ------------------------------------------------------------------------
407 * ISurfaceComposer interface
408 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800409 sp<ISurfaceComposerClient> createConnection() override;
410 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
411 void destroyDisplay(const sp<IBinder>& displayToken) override;
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800412 std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override;
413 sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800414 void setTransactionState(const Vector<ComposerState>& state,
415 const Vector<DisplayState>& displays, uint32_t flags,
416 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800417 const InputWindowCommands& inputWindowCommands,
Marissa Wall947d34e2019-03-29 14:03:53 -0700418 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
Valerie Hau9dab9732019-08-20 09:29:25 -0700419 bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700420 const std::vector<ListenerCallbacks>& listenerCallbacks) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800421 void bootFinished() override;
422 bool authenticateSurfaceTexture(
423 const sp<IGraphicBufferProducer>& bufferProducer) const override;
424 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
425 sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700426 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp,
427 ISurfaceComposer::ConfigChanged configChanged =
428 ISurfaceComposer::eConfigChangedSuppress) override;
chaviwd2432892020-07-24 17:42:39 -0700429 status_t captureDisplay(const DisplayCaptureArgs& args,
430 ScreenCaptureResults& captureResults) override;
431 status_t captureDisplay(uint64_t displayOrLayerStack,
432 ScreenCaptureResults& captureResults) override;
chaviw3efadb12020-07-27 10:07:15 -0700433 status_t captureLayers(const LayerCaptureArgs& args,
434 ScreenCaptureResults& captureResults) override;
Robert Carr108b2c72019-04-02 16:32:58 -0700435
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800436 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800437 status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*) override;
438 status_t getDisplayInfo(const sp<IBinder>& displayToken, DisplayInfo*) override;
439 status_t getDisplayConfigs(const sp<IBinder>& displayToken, Vector<DisplayConfig>*) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800440 int getActiveConfig(const sp<IBinder>& displayToken) override;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800441 status_t getDisplayColorModes(const sp<IBinder>& displayToken, Vector<ui::ColorMode>*) override;
Daniel Solomon42d04562019-01-20 21:03:19 -0800442 status_t getDisplayNativePrimaries(const sp<IBinder>& displayToken,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800443 ui::DisplayPrimaries&) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800444 ui::ColorMode getActiveColorMode(const sp<IBinder>& displayToken) override;
445 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100446 status_t getAutoLowLatencyModeSupport(const sp<IBinder>& displayToken,
447 bool* outSupported) const override;
448 void setAutoLowLatencyMode(const sp<IBinder>& displayToken, bool on) override;
449 status_t getGameContentTypeSupport(const sp<IBinder>& displayToken,
450 bool* outSupported) const override;
451 void setGameContentType(const sp<IBinder>& displayToken, bool on) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800452 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800453 status_t clearAnimationFrameStats() override;
454 status_t getAnimationFrameStats(FrameStats* outStats) const override;
455 status_t getHdrCapabilities(const sp<IBinder>& displayToken,
456 HdrCapabilities* outCapabilities) const override;
457 status_t enableVSyncInjections(bool enable) override;
458 status_t injectVSync(nsecs_t when) override;
Vishnu Nair43bccf82020-06-05 10:53:37 -0700459 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800460 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700461 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
462 ui::Dataspace* outWideColorGamutDataspace,
463 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700464 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& displayToken,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800465 ui::PixelFormat* outFormat,
466 ui::Dataspace* outDataspace,
467 uint8_t* outComponentMask) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700468 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& displayToken, bool enable,
469 uint8_t componentMask, uint64_t maxFrames) override;
470 status_t getDisplayedContentSample(const sp<IBinder>& displayToken, uint64_t maxFrames,
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800471 uint64_t timestamp,
472 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800473 status_t getProtectedContentSupport(bool* outSupported) const override;
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800474 status_t isWideColorDisplay(const sp<IBinder>& displayToken,
475 bool* outIsWideColorDisplay) const override;
Dan Stoza84ab9372018-12-17 15:27:57 -0800476 status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
477 const sp<IRegionSamplingListener>& listener) override;
478 status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override;
Ana Krulec0782b882019-10-15 17:34:54 -0700479 status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken, int32_t displayModeId,
Steven Thomasf734df42020-04-13 21:09:28 -0700480 float primaryRefreshRateMin, float primaryRefreshRateMax,
481 float appRequestRefreshRateMin,
482 float appRequestRefreshRateMax) override;
Ana Krulec234bb162019-11-10 22:55:55 +0100483 status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Steven Thomasf734df42020-04-13 21:09:28 -0700484 int32_t* outDefaultConfig,
485 float* outPrimaryRefreshRateMin,
486 float* outPrimaryRefreshRateMax,
487 float* outAppRequestRefreshRateMin,
488 float* outAppRequestRefreshRateMax) override;
Dan Gittik57e63c52019-01-18 16:37:54 +0000489 status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
490 bool* outSupport) const override;
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700491 status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) override;
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100492 status_t notifyPowerBoost(int32_t boostId) override;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800493 status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
494 float lightPosY, float lightPosZ, float lightRadius) override;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800495 status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
496 int8_t compatibility) override;
Steven Thomasd4071902020-03-24 16:02:53 -0700497 status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700498 /* ------------------------------------------------------------------------
499 * DeathRecipient interface
500 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800501 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800502
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700503 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700504 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700505 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800506 void onFirstRef() override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800507
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700508 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700509 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700510 */
Peiyong Line9d809e2020-04-14 13:10:48 -0700511 void onVsyncReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId, int64_t timestamp,
512 std::optional<hal::VsyncPeriodNanos> vsyncPeriod) override;
513 void onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
514 hal::Connection connection) override;
515 void onRefreshReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId) override;
Ady Abraham7159f572019-10-11 11:10:18 -0700516 void onVsyncPeriodTimingChangedReceived(
Peiyong Line9d809e2020-04-14 13:10:48 -0700517 int32_t sequenceId, hal::HWDisplayId display,
518 const hal::VsyncPeriodChangeTimeline& updatedTimeline) override;
519 void onSeamlessPossible(int32_t sequenceId, hal::HWDisplayId display) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700520
521 /* ------------------------------------------------------------------------
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800522 * ISchedulerCallback
Ady Abraham2139f732019-11-13 18:56:40 -0800523 */
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700524
525 // Toggles hardware VSYNC by calling into HWC.
526 void setVsyncEnabled(bool) override;
527 // Initiates a refresh rate change to be applied on invalidate.
Ady Abraham2139f732019-11-13 18:56:40 -0800528 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ConfigEvent) override;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700529 // Forces full composition on all displays without resetting the scheduler idle timer.
Ady Abraham3a77a7b2019-12-02 18:46:59 -0800530 void repaintEverythingForHWC() override;
Ady Abrahama09852a2020-02-20 14:23:42 -0800531 // Called when kernel idle timer has expired. Used to update the refresh rate overlay.
532 void kernelTimerChanged(bool expired) override;
Ana Krulecb9afd792020-06-11 13:16:15 -0700533 // Toggles the kernel idle timer on or off depending the policy decisions around refresh rates.
534 void toggleKernelIdleTimer();
535 // Keeps track of whether the kernel idle timer is currently enabled, so we don't have to
536 // make calls to sys prop each time.
537 bool mKernelIdleTimerEnabled = false;
538 // Keeps track of whether the kernel timer is supported on the SF side.
539 bool mSupportKernelIdleTimer = false;
Ady Abraham29d0da32020-07-16 18:39:33 -0700540 // Show spinner with refresh rate overlay
541 bool mRefreshRateOverlaySpinner = false;
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700542
Ady Abraham2139f732019-11-13 18:56:40 -0800543 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700544 * Message handling
545 */
Steven Thomas6d8110b2017-08-31 18:24:21 -0700546 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700547 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700548 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700549 void signalLayerUpdate();
550 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800551
Ady Abraham2139f732019-11-13 18:56:40 -0800552 using RefreshRate = scheduler::RefreshRateConfigs::RefreshRate;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700553
Ady Abraham03b02dd2019-03-21 15:40:11 -0700554 struct ActiveConfigInfo {
Ady Abraham2139f732019-11-13 18:56:40 -0800555 HwcConfigIndexType configId;
Josh Gaoa0520712019-11-14 15:38:04 -0800556 Scheduler::ConfigEvent event = Scheduler::ConfigEvent::None;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700557
558 bool operator!=(const ActiveConfigInfo& other) const {
Ady Abraham2139f732019-11-13 18:56:40 -0800559 return configId != other.configId || event != other.event;
Ady Abraham03b02dd2019-03-21 15:40:11 -0700560 }
561 };
562
Andy McFadden13a082e2012-08-24 10:16:42 -0700563 // called on the main thread in response to initializeDisplays()
Dominik Laskowski83b88212018-12-11 13:34:06 -0800564 void onInitializeDisplays() REQUIRES(mStateLock);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800565 // Sets the desired active config bit. It obtains the lock, and sets mDesiredActiveConfig.
Ady Abraham03b02dd2019-03-21 15:40:11 -0700566 void setDesiredActiveConfig(const ActiveConfigInfo& info) REQUIRES(mStateLock);
Steven Thomasa87ed452020-01-03 16:10:05 -0800567 status_t setActiveConfig(const sp<IBinder>& displayToken, int id);
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800568 // Once HWC has returned the present fence, this sets the active config and a new refresh
Ady Abraham53852a52019-05-28 18:07:44 -0700569 // rate in SF.
Ana Kruleca5bdd9d2019-01-29 19:00:58 -0800570 void setActiveConfigInternal() REQUIRES(mStateLock);
Ady Abraham27cbed72020-04-10 12:56:59 -0700571 // Calls to setActiveConfig on the main thread if there is a pending config
572 // that needs to be applied.
573 void performSetActiveConfig() REQUIRES(mStateLock);
Ady Abraham53852a52019-05-28 18:07:44 -0700574 // Called when active config is no longer is progress
575 void desiredActiveConfigChangeDone() REQUIRES(mStateLock);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700576 // called on the main thread in response to setPowerMode()
Peiyong Lin65248e02020-04-18 21:15:07 -0700577 void setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode)
578 REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800579
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100580 // Sets the desired display configs.
Steven Thomasd4071902020-03-24 16:02:53 -0700581 status_t setDesiredDisplayConfigSpecsInternal(
582 const sp<DisplayDevice>& display,
583 const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy)
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100584 EXCLUDES(mStateLock);
Ady Abraham838de062019-02-04 10:24:03 -0800585
Dan Stoza28d46a52020-04-28 09:54:54 -0700586 // Handle the INVALIDATE message queue event, latching new buffers and applying
587 // incoming transactions
588 void onMessageInvalidate(nsecs_t expectedVSyncTime);
589
Dan Stoza6b9454d2014-11-07 16:00:59 -0800590 // Returns whether the transaction actually modified any state
591 bool handleMessageTransaction();
592
Dan Stoza28d46a52020-04-28 09:54:54 -0700593 // Handle the REFRESH message queue event, sending the current frame down to RenderEngine and
594 // the Composer HAL for presentation
595 void onMessageRefresh();
596
Dan Stoza6b9454d2014-11-07 16:00:59 -0800597 // Returns whether a new buffer has been latched (see handlePageFlip())
598 bool handleMessageInvalidate();
599
Mathias Agopian87baae12012-07-31 12:38:26 -0700600 void handleTransaction(uint32_t transactionFlags);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800601 void handleTransactionLocked(uint32_t transactionFlags) REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800602
Vishnu Nair6194e2e2019-02-06 12:58:39 -0800603 void updateInputFlinger();
604 void updateInputWindowInfo();
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800605 void commitInputWindowCommands() REQUIRES(mStateLock);
Riley Andrews03414a12014-07-01 14:22:59 -0700606 void updateCursorAsync();
Marin Shalamanova524a092020-07-27 21:39:55 +0200607 void initScheduler(PhysicalDisplayId primaryDisplayId);
Riley Andrews03414a12014-07-01 14:22:59 -0700608
Dan Stoza6b9454d2014-11-07 16:00:59 -0800609 /* handlePageFlip - latch a new buffer if available and compute the dirty
610 * region. Returns whether a new buffer has been latched, i.e., whether it
611 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700612 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800613 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800614
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700615 /* ------------------------------------------------------------------------
616 * Transactions
617 */
Marissa Wall713b63f2018-10-17 15:42:43 -0700618 void applyTransactionState(const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800619 const Vector<DisplayState>& displays, uint32_t flags,
Robert Carr14167e02019-02-13 13:50:55 -0800620 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -0700621 const int64_t desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -0700622 const client_cache_t& uncacheBuffer, const int64_t postTime,
623 bool privileged, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700624 const std::vector<ListenerCallbacks>& listenerCallbacks,
Valerie Hau9dab9732019-08-20 09:29:25 -0700625 bool isMainThread = false) REQUIRES(mStateLock);
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700626 // Returns true if at least one transaction was flushed
Marissa Wall713b63f2018-10-17 15:42:43 -0700627 bool flushTransactionQueues();
Marissa Walle6e3c0d2019-03-29 10:28:30 -0700628 // Returns true if there is at least one transaction that needs to be flushed
629 bool transactionFlushNeeded();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700630 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800631 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700632 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700633 uint32_t setTransactionFlags(uint32_t flags);
Valerie Haud50e7412020-06-16 17:58:14 -0700634 // Indicate SF should call doTraversal on layers, but don't trigger a wakeup! We use this cases
635 // where there are still pending transactions but we know they won't be ready until a frame
Robert Carr4b874132020-05-29 12:02:51 -0700636 // arrives from a different layer. So we need to ensure we performTransaction from invalidate
637 // but there is no need to try and wake up immediately to do it. Rather we rely on
Valerie Haud50e7412020-06-16 17:58:14 -0700638 // onFrameAvailable or another layer update to wake us up.
639 void setTraversalNeeded();
Ana Krulec7ecce8c2018-10-12 13:44:41 -0700640 uint32_t setTransactionFlags(uint32_t flags, Scheduler::TransactionStart transactionStart);
Nataniel Borges2b796da2019-02-15 13:32:18 -0800641 void commitTransaction() REQUIRES(mStateLock);
chaviw74d90ad2019-04-26 14:45:26 -0700642 void commitOffscreenLayers();
Marissa Wall17b4e452018-12-26 16:32:34 -0800643 bool transactionIsReadyToBeApplied(int64_t desiredPresentTime,
644 const Vector<ComposerState>& states);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800645 uint32_t setDisplayStateLocked(const DisplayState& s) REQUIRES(mStateLock);
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800646 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands)
647 REQUIRES(mStateLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800648
Lloyd Pique58e24a32019-08-01 15:50:14 -0700649protected:
650 virtual uint32_t setClientStateLocked(
651 const ComposerState& composerState, int64_t desiredPresentTime, int64_t postTime,
652 bool privileged,
653 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks)
654 REQUIRES(mStateLock);
655 virtual void commitTransactionLocked();
656
Lloyd Pique7eebe692020-04-22 22:40:06 -0700657 // Used internally by computeLayerBounds() to gets the clip rectangle to use for the
658 // root layers on a particular display in layer-coordinate space. The
659 // layers (and effectively their children) will be clipped against this
660 // rectangle. The base behavior is to clip to the visible region of the
661 // display.
662 virtual FloatRect getLayerClipBoundsForDisplay(const DisplayDevice&) const;
663
Lloyd Pique58e24a32019-08-01 15:50:14 -0700664private:
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700665 /* ------------------------------------------------------------------------
666 * Layer management
667 */
Marissa Wall2d814fb2019-04-09 18:52:57 +0000668 status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
669 PixelFormat format, uint32_t flags, LayerMetadata metadata,
Robert Carrc0df3122019-04-11 13:18:21 -0700670 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp,
Valerie Hau1acd6962019-10-28 16:35:48 -0700671 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer = nullptr,
672 uint32_t* outTransformHint = nullptr);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800673
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700674 status_t createBufferQueueLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800675 uint32_t h, uint32_t flags, LayerMetadata metadata,
676 PixelFormat& format, sp<IBinder>* outHandle,
677 sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800678
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700679 status_t createBufferStateLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800680 uint32_t h, uint32_t flags, LayerMetadata metadata,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700681 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Marissa Wall61c58622018-07-18 10:12:20 -0700682
Vishnu Nairfa247b12020-02-11 08:58:26 -0800683 status_t createEffectLayer(const sp<Client>& client, std::string name, uint32_t w, uint32_t h,
684 uint32_t flags, LayerMetadata metadata, sp<IBinder>* outHandle,
685 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700686
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700687 status_t createContainerLayer(const sp<Client>& client, std::string name, uint32_t w,
Evan Roskya1f1e152019-01-24 16:17:46 -0800688 uint32_t h, uint32_t flags, LayerMetadata metadata,
689 sp<IBinder>* outHandle, sp<Layer>* outLayer);
Robert Carr6b3f6c52018-08-13 13:05:17 -0700690
chaviwfe94a222019-08-21 13:52:59 -0700691 status_t mirrorLayer(const sp<Client>& client, const sp<IBinder>& mirrorFromHandle,
692 sp<IBinder>* outHandle);
693
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700694 std::string getUniqueLayerName(const char* name);
Cody Northropbc755282017-03-31 12:00:08 -0600695
Rob Carr4bba3702018-10-08 21:53:30 +0000696 // called when all clients have released all their references to
697 // this layer meaning it is entirely safe to destroy all
698 // resources associated to this layer.
Robert Carr695d5282018-12-18 15:27:58 -0800699 void onHandleDestroyed(sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800700 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700701
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700702 // add a layer to SurfaceFlinger
Robert Carrc0df3122019-04-11 13:18:21 -0700703 status_t addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
704 const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
705 const sp<IBinder>& parentHandle, const sp<Layer>& parentLayer,
Vishnu Nair6213bd92020-05-08 17:42:25 -0700706 bool addToCurrentState, uint32_t* outTransformHint);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700707
Vishnu Nair4351ad52019-02-11 14:13:02 -0800708 // Traverse through all the layers and compute and cache its bounds.
709 void computeLayerBounds();
710
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700711 /* ------------------------------------------------------------------------
712 * Boot animation, on/off animations and screen capture
713 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700714
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700715 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700716
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700717 using TraverseLayersFunction = std::function<void(const LayerVector::Visitor&)>;
Marin Shalamanov1c434292020-06-12 01:47:29 +0200718 using RenderAreaFuture = std::future<std::unique_ptr<RenderArea>>;
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700719
chaviw426b5c02020-07-27 11:20:15 -0700720 status_t renderScreenImplLocked(const RenderArea& renderArea,
721 TraverseLayersFunction traverseLayers,
722 const sp<GraphicBuffer>& buffer, bool useIdentityTransform,
723 bool forSystem, int* outSyncFd, bool regionSampling,
724 ScreenCaptureResults& captureResults);
Marin Shalamanov1c434292020-06-12 01:47:29 +0200725 status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, ui::Size bufferSize,
chaviw426b5c02020-07-27 11:20:15 -0700726 ui::PixelFormat, bool useIdentityTransform,
727 ScreenCaptureResults& captureResults);
Marin Shalamanov1c434292020-06-12 01:47:29 +0200728 status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, const sp<GraphicBuffer>&,
729 bool useIdentityTransform, bool regionSampling,
chaviw426b5c02020-07-27 11:20:15 -0700730 ScreenCaptureResults& captureResults);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700731 sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) REQUIRES(mStateLock);
732 sp<DisplayDevice> getDisplayByLayerStack(uint64_t layerStack) REQUIRES(mStateLock);
chaviw426b5c02020-07-27 11:20:15 -0700733
chaviw4b9d5e12020-08-04 18:30:35 -0700734 // If the uid provided is not UNSET_UID, the traverse will skip any layers that don't have a
735 // matching ownerUid
736 void traverseLayersInLayerStack(ui::LayerStack, const int32_t uid, const LayerVector::Visitor&);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700737
Lloyd Pique90c115d2018-09-18 21:39:42 -0700738 sp<StartPropertySetThread> mStartPropertySetThread;
Wei Wangb254fa32017-01-31 17:43:23 -0800739
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700740 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700741 * Properties
742 */
743 void readPersistentProperties();
744
745 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700746 * EGL
747 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700748 size_t getMaxTextureSize() const;
749 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700750
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700751 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700752 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700753 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700754 // called when starting, or restarting after system_server death
755 void initializeDisplays();
756
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700757 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const
758 REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700759 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700760 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700761
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700762 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700763 const auto it = mDisplays.find(displayToken);
764 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700765 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700766
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700767 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700768 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700769 }
770
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700771 sp<DisplayDevice> getDefaultDisplayDeviceLocked() REQUIRES(mStateLock) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800772 if (const auto token = getInternalDisplayTokenLocked()) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700773 return getDisplayDeviceLocked(token);
774 }
775 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700776 }
777
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700778 sp<const DisplayDevice> getDefaultDisplayDevice() EXCLUDES(mStateLock) {
779 Mutex::Autolock lock(mStateLock);
780 return getDefaultDisplayDeviceLocked();
781 }
Marin Shalamanovf5de90d2019-10-08 10:57:25 +0200782
Mathias Agopian87baae12012-07-31 12:38:26 -0700783 // mark a region of a layer stack dirty. this updates the dirty
784 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700785 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700786
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700787 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700788 * H/W composer
789 */
790
Lloyd Pique441d5042018-10-18 16:49:51 -0700791 // The current hardware composer interface.
792 //
793 // The following thread safety rules apply when accessing mHwc, either
794 // directly or via getHwComposer():
795 //
796 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
797 // only when switching into and out of vr. Recreating mHwc must only be
798 // done on the main thread.
799 //
800 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
801 // mStateLock.
802 //
803 // 3. When accessing mHwc on a thread other than the main thread, we always
804 // need to acquire mStateLock. This is because the main thread could be
805 // in the process of destroying the current mHwc instance.
806 //
807 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
808 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
809 // destroy it, so it's always safe to access mHwc from any thread without
810 // acquiring mStateLock.
811 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700812
Mathias Agopian888c8222012-08-04 21:10:38 -0700813 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700814 * Compositing
815 */
816 void invalidateHwcGeometry();
Mathias Agopiancd60f992012-08-16 16:28:27 -0700817
David Sodman2b406362017-12-15 13:33:47 -0800818 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800819 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700820 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
821 std::shared_ptr<FenceTime>& presentFenceTime);
822 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
823 nsecs_t compositeToPresentLatency);
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600824
David Sodmanfa9b2af2017-12-24 13:28:59 -0800825 void postFrame();
Mathias Agopian4da75192010-08-10 17:19:56 -0700826
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700827 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700828 * Display management
829 */
Lloyd Pique542307f2018-10-19 13:24:08 -0700830 sp<DisplayDevice> setupNewDisplayDeviceInternal(
Lloyd Pique9370a482019-10-03 17:58:30 -0700831 const wp<IBinder>& displayToken,
832 std::shared_ptr<compositionengine::Display> compositionDisplay,
Lloyd Pique542307f2018-10-19 13:24:08 -0700833 const DisplayDeviceState& state,
Marin Shalamanovae685592020-02-12 17:12:22 +0100834 const sp<compositionengine::DisplaySurface>& displaySurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700835 const sp<IGraphicBufferProducer>& producer) REQUIRES(mStateLock);
Dominik Laskowski20134642020-04-20 22:36:44 -0700836 void processDisplayChangesLocked() REQUIRES(mStateLock);
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700837 void processDisplayAdded(const wp<IBinder>& displayToken, const DisplayDeviceState&)
838 REQUIRES(mStateLock);
839 void processDisplayRemoved(const wp<IBinder>& displayToken) REQUIRES(mStateLock);
Marin Shalamanovae685592020-02-12 17:12:22 +0100840 void processDisplayChanged(const wp<IBinder>& displayToken,
841 const DisplayDeviceState& currentState,
Dominik Laskowski20134642020-04-20 22:36:44 -0700842 const DisplayDeviceState& drawingState) REQUIRES(mStateLock);
843 void processDisplayHotplugEventsLocked() REQUIRES(mStateLock);
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700844
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800845 void dispatchDisplayHotplugEvent(PhysicalDisplayId displayId, bool connected);
Dominik Laskowski1eba0202019-01-24 09:14:40 -0800846
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700847 /* ------------------------------------------------------------------------
848 * VSync
849 */
Ady Abraham2492a022020-07-24 11:09:55 -0700850 nsecs_t getVsyncPeriodFromHWC() const REQUIRES(mStateLock);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700851
Dominik Laskowskiccf37d72019-02-01 16:47:58 -0800852 // Sets the refresh rate by switching active configs, if they are available for
Ana Krulec7d1d6832018-12-27 11:10:09 -0800853 // the desired refresh rate.
Ady Abraham2139f732019-11-13 18:56:40 -0800854 void changeRefreshRateLocked(const RefreshRate&, Scheduler::ConfigEvent event)
855 REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700856
Ady Abraham2139f732019-11-13 18:56:40 -0800857 bool isDisplayConfigAllowed(HwcConfigIndexType configId) const REQUIRES(mStateLock);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700858
Alec Mouri6d414b52020-03-17 11:18:05 -0700859 // Gets the fence for the previous frame.
860 // Must be called on the main thread.
861 sp<Fence> previousFrameFence();
862
863 // Whether the previous frame has not yet been presented to the display.
864 // If graceTimeMs is positive, this method waits for at most the provided
865 // grace period before reporting if the frame missed.
866 // Must be called on the main thread.
867 bool previousFramePending(int graceTimeMs = 0);
868
869 // Returns the previous time that the frame was presented. If the frame has
870 // not been presented yet, then returns Fence::SIGNAL_TIME_PENDING. If there
871 // is no pending frame, then returns Fence::SIGNAL_TIME_INVALID.
872 // Must be called on the main thread.
873 nsecs_t previousFramePresentTime();
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700874
Ady Abraham5facfb12020-04-22 15:18:31 -0700875 // Calculates the expected present time for this frame. For negative offsets, performs a
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700876 // correction using the predicted vsync for the next frame instead.
Ady Abraham5facfb12020-04-22 15:18:31 -0700877 nsecs_t calculateExpectedPresentTime(nsecs_t now) const;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -0700878
Dominik Laskowskic2867142019-01-21 11:33:38 -0800879 /*
880 * Display identification
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700881 */
Marin Shalamanova524a092020-07-27 21:39:55 +0200882 sp<IBinder> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
883 REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700884 const auto it = mPhysicalDisplayTokens.find(displayId);
885 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
886 }
887
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700888 std::optional<DisplayId> getPhysicalDisplayIdLocked(const sp<IBinder>& displayToken) const
889 REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700890 for (const auto& [id, token] : mPhysicalDisplayTokens) {
891 if (token == displayToken) {
892 return id;
893 }
894 }
895 return {};
896 }
897
898 // TODO(b/74619554): Remove special cases for primary display.
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700899 sp<IBinder> getInternalDisplayTokenLocked() const REQUIRES(mStateLock) {
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800900 const auto displayId = getInternalDisplayIdLocked();
901 return displayId ? getPhysicalDisplayTokenLocked(*displayId) : nullptr;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700902 }
903
Marin Shalamanova524a092020-07-27 21:39:55 +0200904 std::optional<PhysicalDisplayId> getInternalDisplayIdLocked() const REQUIRES(mStateLock) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700905 const auto hwcDisplayId = getHwComposer().getInternalHwcDisplayId();
906 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
907 }
908
Dominik Laskowskic2867142019-01-21 11:33:38 -0800909 /*
910 * Debugging & dumpsys
911 */
Dominik Laskowskic2867142019-01-21 11:33:38 -0800912 using DumpArgs = Vector<String16>;
913 using Dumper = std::function<void(const DumpArgs&, bool asProto, std::string&)>;
914
915 template <typename F, std::enable_if_t<!std::is_member_function_pointer_v<F>>* = nullptr>
916 static Dumper dumper(F&& dump) {
917 using namespace std::placeholders;
918 return std::bind(std::forward<F>(dump), _3);
919 }
920
921 template <typename F, std::enable_if_t<std::is_member_function_pointer_v<F>>* = nullptr>
922 Dumper dumper(F dump) {
923 using namespace std::placeholders;
924 return std::bind(dump, this, _3);
925 }
926
927 template <typename F>
928 Dumper argsDumper(F dump) {
929 using namespace std::placeholders;
930 return std::bind(dump, this, _1, _3);
931 }
932
933 template <typename F>
934 Dumper protoDumper(F dump) {
935 using namespace std::placeholders;
936 return std::bind(dump, this, _1, _2, _3);
937 }
938
939 void dumpAllLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
940
941 void appendSfConfigString(std::string& result) const;
942 void listLayersLocked(std::string& result) const;
943 void dumpStatsLocked(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
944 void clearStatsLocked(const DumpArgs& args, std::string& result);
945 void dumpTimeStats(const DumpArgs& args, bool asProto, std::string& result) const;
Jamie Gennis6547ff42013-07-16 20:12:42 -0700946 void logFrameStats();
947
Dominik Laskowskid9e4de62019-01-21 14:23:01 -0800948 void dumpVSync(std::string& result) const REQUIRES(mStateLock);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800949 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700950 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -0800951 void dumpFrameEventsLocked(std::string& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800952
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700953 void recordBufferingStats(const std::string& layerName,
954 std::vector<OccupancyTracker::Segment>&& history);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800955 void dumpBufferingStats(std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700956 void dumpDisplayIdentificationData(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowskib6e54372019-09-04 14:06:28 -0700957 void dumpRawDisplayIdentificationData(const DumpArgs&, std::string& result) const;
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700958 void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
Dominik Laskowski542c9dc2020-04-10 12:42:02 -0700959 LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
Vishnu Nair0f085c62019-08-30 08:49:12 -0700960 void dumpOffscreenLayersProto(LayersProto& layersProto,
961 uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
Alec Mouri6b9e9912020-01-21 10:50:24 -0800962 // Dumps state from HW Composer
963 void dumpHwc(std::string& result) const;
Vishnu Nair8406fd72019-07-30 11:29:31 -0700964 LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)
965 EXCLUDES(mStateLock);
Vishnu Nair0f085c62019-08-30 08:49:12 -0700966 void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
Dan Stozae77c7662016-05-13 11:37:28 -0700967
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800968 bool isLayerTripleBufferingDisabled() const {
969 return this->mLayerTripleBufferingDisabled;
970 }
Dominik Laskowskic2867142019-01-21 11:33:38 -0800971
972 status_t doDump(int fd, const DumpArgs& args, bool asProto);
973
Nataniel Borges8e7dc722019-02-28 15:10:28 -0800974 status_t dumpCritical(int fd, const DumpArgs&, bool asProto);
Dominik Laskowskic2867142019-01-21 11:33:38 -0800975
976 status_t dumpAll(int fd, const DumpArgs& args, bool asProto) override {
977 return doDump(fd, args, asProto);
978 }
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800979
Steven Thomasd4071902020-03-24 16:02:53 -0700980 void onFrameRateFlexibilityTokenReleased();
981
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800982 /* ------------------------------------------------------------------------
983 * VrFlinger
984 */
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700985 void resetDisplayState() REQUIRES(mStateLock);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800986
Steven Thomas050b2c82017-03-06 11:45:16 -0800987 // Check to see if we should handoff to vr flinger.
988 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800989
Chia-I Wu28f320b2018-05-03 11:02:56 -0700990 void updateColorMatrixLocked();
991
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700992 /* ------------------------------------------------------------------------
993 * Attributes
994 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800995
Lloyd Pique90c115d2018-09-18 21:39:42 -0700996 surfaceflinger::Factory& mFactory;
997
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700998 // access must be protected by mStateLock
999 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -07001000 State mCurrentState{LayerVector::StateSet::Current};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001001 std::atomic<int32_t> mTransactionFlags = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001002 Condition mTransactionCV;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001003 bool mTransactionPending = false;
1004 bool mAnimTransactionPending = false;
1005 SortedVector<sp<Layer>> mLayersPendingRemoval;
Valerie Haud50e7412020-06-16 17:58:14 -07001006 bool mForceTraversal = false;
Dan Stoza101d8dc2018-02-27 15:42:25 -08001007
Chia-I Wu28f320b2018-05-03 11:02:56 -07001008 // global color transform states
1009 Daltonizer mDaltonizer;
1010 float mGlobalSaturationFactor = 1.0f;
1011 mat4 mClientColorMatrix;
1012
Dan Stoza101d8dc2018-02-27 15:42:25 -08001013 // Can't be unordered_set because wp<> isn't hashable
1014 std::set<wp<IBinder>> mGraphicBufferProducerList;
Ady Abrahamb89ca7d2020-03-04 11:19:37 -08001015 size_t mMaxGraphicBufferProducerListSize = ISurfaceComposer::MAX_LAYERS;
Alec Mouri601393f2020-02-21 13:26:52 -08001016 // If there are more GraphicBufferProducers tracked by SurfaceFlinger than
1017 // this threshold, then begin logging.
1018 size_t mGraphicBufferProducerListSizeLogThreshold =
1019 static_cast<size_t>(0.95 * static_cast<double>(MAX_LAYERS));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001020
Dominik Laskowskidd4ef272020-04-23 14:02:12 -07001021 void removeGraphicBufferProducerAsync(const wp<IBinder>&);
1022
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001023 // protected by mStateLock (but we could use another lock)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001024 bool mLayersRemoved = false;
1025 bool mLayersAdded = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001026
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001027 std::atomic<bool> mRepaintEverything = false;
Mathias Agopianca4d3602011-05-19 15:38:14 -07001028
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001029 // constant members (no synchronization needed for access)
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001030 const nsecs_t mBootTime = systemTime();
1031 bool mGpuToCpuSupported = false;
Alec Mouri5f487d42020-02-06 09:26:19 -08001032 bool mIsUserBuild = true;
Mathias Agopian3094df32012-06-18 18:06:45 -07001033
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001034 // Can only accessed from the main thread, these members
1035 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -07001036 State mDrawingState{LayerVector::StateSet::Drawing};
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001037 bool mVisibleRegionsDirty = false;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001038 // Set during transaction commit stage to track if the input info for a layer has changed.
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001039 bool mInputInfoChanged = false;
1040 bool mGeometryInvalid = false;
1041 bool mAnimCompositionPending = false;
Dan Stoza9e56aa02015-11-02 13:00:03 -08001042 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Vishnu Nair6194e2e2019-02-06 12:58:39 -08001043 // Tracks layers that need to update a display's dirty region.
1044 std::vector<sp<Layer>> mLayersPendingRefresh;
Ady Abrahambe0f9482019-04-24 15:41:53 -07001045 std::array<sp<Fence>, 2> mPreviousPresentFences = {Fence::NO_FENCE, Fence::NO_FENCE};
Alec Mouricc0fc602019-02-26 21:45:19 -08001046 // True if in the previous frame at least one layer was composed via the GPU.
Dan Stoza05dacfb2016-07-01 13:33:38 -07001047 bool mHadClientComposition = false;
Alec Mouricc0fc602019-02-26 21:45:19 -08001048 // True if in the previous frame at least one layer was composed via HW Composer.
1049 // Note that it is possible for a frame to be composed via both client and device
1050 // composition, for example in the case of overlays.
1051 bool mHadDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08001052 // True if in the previous frame, the client composition was skipped by reusing the buffer
1053 // used in a previous composition. This can happed if the client composition requests
1054 // did not change.
1055 bool mReusedClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001056
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001057 enum class BootStage {
1058 BOOTLOADER,
1059 BOOTANIMATION,
1060 FINISHED,
1061 };
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001062 BootStage mBootStage = BootStage::BOOTLOADER;
Chia-I Wu14c9c7b2018-06-26 10:18:18 +08001063
Lloyd Piqueba04e622017-12-14 17:11:26 -08001064 struct HotplugEvent {
Peiyong Line9d809e2020-04-14 13:10:48 -07001065 hal::HWDisplayId hwcDisplayId;
1066 hal::Connection connection = hal::Connection::INVALID;
Lloyd Piqueba04e622017-12-14 17:11:26 -08001067 };
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001068 std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mStateLock);
Lloyd Piqueba04e622017-12-14 17:11:26 -08001069
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001070 // this may only be written from the main thread with mStateLock held
1071 // it may be read from other threads with mStateLock held
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001072 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
Marin Shalamanova524a092020-07-27 21:39:55 +02001073 std::unordered_map<PhysicalDisplayId, sp<IBinder>> mPhysicalDisplayTokens
1074 GUARDED_BY(mStateLock);
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001075
Dominik Laskowski0a1435d2020-04-21 00:27:31 -07001076 std::unordered_map<BBinder*, wp<Layer>> mLayersByLocalBinderToken GUARDED_BY(mStateLock);
Robert Carrc0df3122019-04-11 13:18:21 -07001077
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001078 // don't use a lock for these, we don't care
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001079 int mDebugRegion = 0;
1080 bool mDebugDisableHWC = false;
1081 bool mDebugDisableTransformHint = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001082 volatile nsecs_t mDebugInTransaction = 0;
1083 bool mForceFullDamage = false;
Ady Abrahamadb9a992019-09-19 21:21:55 +00001084 bool mPropagateBackpressureClientComposition = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001085 std::unique_ptr<SurfaceInterceptor> mInterceptor;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001086
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001087 SurfaceTracing mTracing{*this};
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001088 std::mutex mTracingLock;
Nataniel Borges2b796da2019-02-15 13:32:18 -08001089 bool mTracingEnabled = false;
Vishnu Nair60db8c02020-04-02 11:55:16 -07001090 bool mAddCompositionStateToTrace = false;
Dominik Laskowski542c9dc2020-04-10 12:42:02 -07001091 std::atomic<bool> mTracingEnabledChanged = false;
1092
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001093 const std::shared_ptr<TimeStats> mTimeStats;
Mikael Pessa90092f42019-08-26 17:22:04 -07001094 const std::unique_ptr<FrameTracer> mFrameTracer;
Fabien Sanglard642b23d2017-02-09 12:29:39 -08001095 bool mUseHwcVirtualDisplays = false;
Lucas Dupin00f16422020-03-11 11:33:04 -07001096 // If blurs should be enabled on this device.
1097 bool mSupportsBlur = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001098 // Disable blurs, for debugging
Lucas Dupin00f16422020-03-11 11:33:04 -07001099 std::atomic<bool> mDisableBlurs = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08001100 // If blurs are considered expensive and should require high GPU frequency.
1101 bool mBlursAreExpensive = false;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001102 std::atomic<uint32_t> mFrameMissedCount = 0;
1103 std::atomic<uint32_t> mHwcFrameMissedCount = 0;
1104 std::atomic<uint32_t> mGpuFrameMissedCount = 0;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001105
Marissa Walle2ffb422018-10-12 11:33:52 -07001106 TransactionCompletedThread mTransactionCompletedThread;
1107
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -08001108 // Restrict layers to use two buffers in their bufferqueues.
1109 bool mLayerTripleBufferingDisabled = false;
1110
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001111 // these are thread safe
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001112 std::unique_ptr<MessageQueue> mEventQueue;
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001113 FrameTracker mAnimFrameTracker;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001114
1115 // protected by mDestroyedLayerLock;
1116 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -08001117 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001118
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001119 nsecs_t mRefreshStartTime = 0;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -07001120
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001121 std::atomic<bool> mRefreshPending = false;
Dan Stoza2b6d38e2017-06-01 16:40:30 -07001122
Dan Stoza436ccf32018-06-21 12:10:12 -07001123 // We maintain a pool of pre-generated texture names to hand out to avoid
1124 // layer creation needing to run on the main thread (which it would
1125 // otherwise need to do to access RenderEngine).
1126 std::mutex mTexturePoolMutex;
1127 uint32_t mTexturePoolSize = 0;
1128 std::vector<uint32_t> mTexturePool;
1129
Marissa Wall713b63f2018-10-17 15:42:43 -07001130 struct TransactionState {
1131 TransactionState(const Vector<ComposerState>& composerStates,
Marissa Wall17b4e452018-12-26 16:32:34 -08001132 const Vector<DisplayState>& displayStates, uint32_t transactionFlags,
Marissa Wall947d34e2019-03-29 14:03:53 -07001133 int64_t desiredPresentTime, const client_cache_t& uncacheBuffer,
Valerie Hau9dab9732019-08-20 09:29:25 -07001134 int64_t postTime, bool privileged, bool hasListenerCallbacks,
1135 std::vector<ListenerCallbacks> listenerCallbacks)
Marissa Wall17b4e452018-12-26 16:32:34 -08001136 : states(composerStates),
1137 displays(displayStates),
1138 flags(transactionFlags),
Valerie Haubc6ddb12019-03-08 11:10:15 -08001139 desiredPresentTime(desiredPresentTime),
Marissa Wall78b72202019-03-15 14:58:34 -07001140 buffer(uncacheBuffer),
Valerie Haubc6ddb12019-03-08 11:10:15 -08001141 postTime(postTime),
Valerie Hau9dab9732019-08-20 09:29:25 -07001142 privileged(privileged),
1143 hasListenerCallbacks(hasListenerCallbacks),
1144 listenerCallbacks(listenerCallbacks) {}
Marissa Wall713b63f2018-10-17 15:42:43 -07001145
1146 Vector<ComposerState> states;
1147 Vector<DisplayState> displays;
1148 uint32_t flags;
Valerie Haubc6ddb12019-03-08 11:10:15 -08001149 const int64_t desiredPresentTime;
Marissa Wall947d34e2019-03-29 14:03:53 -07001150 client_cache_t buffer;
Valerie Haubc6ddb12019-03-08 11:10:15 -08001151 const int64_t postTime;
Robert Carr14167e02019-02-13 13:50:55 -08001152 bool privileged;
Valerie Hau9dab9732019-08-20 09:29:25 -07001153 bool hasListenerCallbacks;
1154 std::vector<ListenerCallbacks> listenerCallbacks;
Marissa Wall713b63f2018-10-17 15:42:43 -07001155 };
Valerie Hau5de3ad22019-08-20 07:47:43 -07001156 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash> mTransactionQueues;
Marissa Wall713b63f2018-10-17 15:42:43 -07001157
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001158 /* ------------------------------------------------------------------------
1159 * Feature prototyping
1160 */
1161
Dan Stozab90cf072015-03-05 11:05:59 -08001162 // Static screen stats
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001163 bool mHasPoweredOff = false;
Dan Stozae77c7662016-05-13 11:37:28 -07001164
chaviweadf0d42019-08-12 13:28:29 -07001165 std::atomic<size_t> mNumLayers = 0;
Robert Carr1f0a16a2016-10-24 16:27:39 -07001166
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07001167 // Verify that transaction is being called by an approved process:
1168 // either AID_GRAPHICS or AID_SYSTEM.
1169 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001170
Steven Morelanda904bb92019-07-02 17:37:23 -07001171 // to linkToDeath
1172 sp<IBinder> mWindowManager;
Rob Carr2aa78cb2020-03-10 14:27:49 -07001173 // We want to avoid multiple calls to BOOT_FINISHED as they come in on
1174 // different threads without a lock and could trigger unsynchronized writes to
1175 // to mWindowManager or mInputFlinger
1176 std::atomic<bool> mBootFinished = false;
Steven Morelanda904bb92019-07-02 17:37:23 -07001177
Steven Thomasb02664d2017-07-26 18:48:28 -07001178 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001179 std::atomic<bool> mVrFlingerRequestsDisplay = false;
Steven Thomas050b2c82017-03-06 11:45:16 -08001180 static bool useVrFlinger;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001181 std::thread::id mMainThreadId = std::this_thread::get_id();
Romain Guy0147a172017-06-01 13:53:56 -07001182
Lloyd Pique6a3b4462019-03-07 20:58:12 -08001183 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::kEnhanced;
David Sodman105b7dc2017-11-04 20:28:14 -07001184
Peiyong Lina3ea5592019-02-10 14:45:00 -08001185 // Color mode forced by setting persist.sys.sf.color_mode, it must:
1186 // 1. not be NATIVE color mode, NATIVE color mode means no forced color mode;
1187 // 2. be one of the supported color modes returned by hardware composer, otherwise
1188 // it will not be respected.
1189 // persist.sys.sf.color_mode will only take effect when persist.sys.sf.native_mode
1190 // is not set to 1.
1191 // This property can be used to force SurfaceFlinger to always pick a certain color mode.
1192 ui::ColorMode mForceColorMode = ui::ColorMode::NATIVE;
1193
Peiyong Lin9d846a52018-11-05 13:18:20 -08001194 ui::Dataspace mDefaultCompositionDataspace;
1195 ui::Dataspace mWideColorGamutCompositionDataspace;
Yichi Chenda901bf2019-06-28 14:58:27 +08001196 ui::Dataspace mColorSpaceAgnosticDataspace;
Peiyong Lin9d846a52018-11-05 13:18:20 -08001197
David Sodman105b7dc2017-11-04 20:28:14 -07001198 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001199 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Ana Krulec98b5b242018-08-10 15:03:23 -07001200
Ana Krulecb43429d2019-01-09 14:28:51 -08001201 /* ------------------------------------------------------------------------
1202 * Scheduler
1203 */
Ana Krulec98b5b242018-08-10 15:03:23 -07001204 std::unique_ptr<Scheduler> mScheduler;
Dominik Laskowski98041832019-08-01 18:35:59 -07001205 scheduler::ConnectionHandle mAppConnectionHandle;
1206 scheduler::ConnectionHandle mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001207
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001208 // Stores phase offsets configured per refresh rate.
Ady Abraham9e16a482019-12-03 17:19:41 -08001209 std::unique_ptr<scheduler::PhaseConfiguration> mPhaseConfiguration;
Dominik Laskowskieddeda12019-07-19 11:54:13 -07001210
1211 // Optional to defer construction until scheduler connections are created.
1212 std::optional<scheduler::VSyncModulator> mVSyncModulator;
1213
Steven Thomas2bbaabe2019-08-28 16:08:35 -07001214 std::unique_ptr<scheduler::RefreshRateConfigs> mRefreshRateConfigs;
1215 std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;
Ady Abraham1902d072019-03-01 17:18:59 -08001216
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001217 std::atomic<nsecs_t> mExpectedPresentTime = 0;
Marin Shalamanovc75b0772020-06-12 22:29:11 +02001218 hal::Vsync mHWCVsyncPendingState = hal::Vsync::DISABLE;
Dominik Laskowskia8955dd2019-07-10 10:19:09 -07001219
Lloyd Pique8d9f8362020-02-11 19:13:09 -08001220 /* ------------------------------------------------------------------------
1221 * Generic Layer Metadata
1222 */
1223 const std::unordered_map<std::string, uint32_t>& getGenericLayerMetadataKeyMap() const;
1224
1225 /* ------------------------------------------------------------------------
1226 * Misc
1227 */
1228
Dominik Laskowski20134642020-04-20 22:36:44 -07001229 std::optional<ActiveConfigInfo> getDesiredActiveConfig() EXCLUDES(mActiveConfigLock) {
1230 std::lock_guard<std::mutex> lock(mActiveConfigLock);
1231 if (mDesiredActiveConfigChanged) return mDesiredActiveConfig;
1232 return std::nullopt;
1233 }
1234
Ana Kruleca5bdd9d2019-01-29 19:00:58 -08001235 std::mutex mActiveConfigLock;
1236 // This bit is set once we start setting the config. We read from this bit during the
1237 // process. If at the end, this bit is different than mDesiredActiveConfig, we restart
1238 // the process.
1239 ActiveConfigInfo mUpcomingActiveConfig; // Always read and written on the main thread.
1240 // This bit can be set at any point in time when the system wants the new config.
1241 ActiveConfigInfo mDesiredActiveConfig GUARDED_BY(mActiveConfigLock);
1242
Ady Abrahamb838aed2019-02-12 15:30:16 -08001243 // below flags are set by main thread only
Ady Abraham50204dd2019-07-19 15:47:11 -07001244 TracedOrdinal<bool> mDesiredActiveConfigChanged
1245 GUARDED_BY(mActiveConfigLock) = {"DesiredActiveConfigChanged", false};
Ady Abraham27cbed72020-04-10 12:56:59 -07001246 bool mSetActiveConfigPending = false;
Ady Abrahamb838aed2019-02-12 15:30:16 -08001247
Kevin DuBois413287f2019-02-25 08:46:47 -08001248 bool mLumaSampling = true;
1249 sp<RegionSamplingThread> mRegionSamplingThread;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001250 ui::DisplayPrimaries mInternalDisplayPrimaries;
Kevin DuBois413287f2019-02-25 08:46:47 -08001251
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001252 const float mInternalDisplayDensity;
1253 const float mEmulatedDisplayDensity;
1254
Chris Ye0783e992020-06-02 21:34:49 -07001255 sp<os::IInputFlinger> mInputFlinger;
Vishnu Nairfa5f8df2019-02-13 17:02:51 -08001256 InputWindowCommands mPendingInputWindowCommands GUARDED_BY(mStateLock);
1257 // Should only be accessed by the main thread.
chaviw273171b2018-12-26 11:46:30 -08001258 InputWindowCommands mInputWindowCommands;
chaviw291d88a2019-02-14 10:33:58 -08001259
Chris Ye0783e992020-06-02 21:34:49 -07001260 sp<SetInputWindowsListener> mSetInputWindowsListener;
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001261
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -08001262 bool mPendingSyncInputWindows GUARDED_BY(mStateLock) = false;
Peiyong Lin74ca2f42019-01-14 19:36:57 -08001263 Hwc2::impl::PowerAdvisor mPowerAdvisor;
Ady Abraham03b02dd2019-03-21 15:40:11 -07001264
Alec Mouri9519bf12019-11-15 16:54:44 -08001265 // This should only be accessed on the main thread.
1266 nsecs_t mFrameStartTime = 0;
1267
Dominik Laskowski20134642020-04-20 22:36:44 -07001268 void enableRefreshRateOverlay(bool enable);
1269 std::unique_ptr<RefreshRateOverlay> mRefreshRateOverlay GUARDED_BY(mStateLock);
Ady Abraham34392f72019-04-10 11:29:27 -07001270
1271 // Flag used to set override allowed display configs from backdoor
1272 bool mDebugDisplayConfigSetByBackdoor = false;
chaviw74d90ad2019-04-26 14:45:26 -07001273
1274 // A set of layers that have no parent so they are not drawn on screen.
1275 // Should only be accessed by the main thread.
1276 // The Layer pointer is removed from the set when the destructor is called so there shouldn't
1277 // be any issues with a raw pointer referencing an invalid object.
1278 std::unordered_set<Layer*> mOffscreenLayers;
Ady Abraham9ba25122019-06-03 17:10:55 -07001279
Alec Mouri5f487d42020-02-06 09:26:19 -08001280 // Fields tracking the current jank event: when it started and how many
1281 // janky frames there are.
1282 nsecs_t mMissedFrameJankStart = 0;
1283 int32_t mMissedFrameJankCount = 0;
Alec Mouri1b6a60c2020-06-08 13:54:24 -07001284 // Positive if jank should be uploaded in postComposition
1285 nsecs_t mLastJankDuration = -1;
Robert Carra1257842020-01-31 13:48:28 -08001286
Steven Thomasd4071902020-03-24 16:02:53 -07001287 int mFrameRateFlexibilityTokenCount = 0;
Ady Abraham07e54702020-04-16 15:05:37 -07001288
1289 sp<IBinder> mDebugFrameRateFlexibilityToken;
Romain Guy0147a172017-06-01 13:53:56 -07001290};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001291
Dominik Laskowski9dab3432019-03-27 13:21:10 -07001292} // namespace android