blob: c92874bab4995dc803421791ff9d5d896db40919 [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
17#ifndef ANDROID_SURFACE_FLINGER_H
18#define ANDROID_SURFACE_FLINGER_H
19
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -080020#include <memory>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <stdint.h>
22#include <sys/types.h>
23
Mathias Agopian3f844832013-08-07 21:24:32 -070024/*
25 * NOTE: Make sure this file doesn't include anything from <gl/ > or <gl2/ >
26 */
Mathias Agopian921e6ac2012-07-23 23:11:29 -070027
Steven Moreland2716e112018-02-23 14:57:20 -080028#include <cutils/atomic.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080029#include <cutils/compiler.h>
30#include <gui/BufferQueue.h>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080031#include <gui/FrameTimestamps.h>
Mathias Agopian90ac7992012-02-25 18:48:35 -080032#include <gui/ISurfaceComposer.h>
33#include <gui/ISurfaceComposerClient.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>
Mathias Agopian86303202012-07-24 22:46:10 -070036#include <hardware/hwcomposer_defs.h>
Peiyong Lin2acb7d42019-01-14 17:22:27 -080037#include <layerproto/LayerProtoHeader.h>
38#include <math/mat4.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>
43#include <utils/Errors.h>
44#include <utils/KeyedVector.h>
45#include <utils/RefBase.h>
46#include <utils/SortedVector.h>
47#include <utils/Trace.h>
48#include <utils/threads.h>
Michael Wright28f24d02016-07-12 13:30:53 -070049
Mathias Agopian921e6ac2012-07-23 23:11:29 -070050#include "Barrier.h"
Mathias Agopian92a979a2012-08-02 18:32:23 -070051#include "DisplayDevice.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080052#include "DisplayHardware/HWC2.h"
53#include "DisplayHardware/HWComposer.h"
54#include "Effects/Daltonizer.h"
Jamie Gennis4b0eba92013-02-05 13:30:24 -080055#include "FrameTracker.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070056#include "LayerBE.h"
Yiwei Zhang7124ad32018-02-21 13:02:45 -080057#include "LayerStats.h"
Robert Carr2047fae2016-11-28 14:09:09 -080058#include "LayerVector.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070059#include "Scheduler/DispSync.h"
60#include "Scheduler/EventThread.h"
61#include "Scheduler/MessageQueue.h"
Ana Krulec98b5b242018-08-10 15:03:23 -070062#include "Scheduler/Scheduler.h"
Ana Krulecfefcb582018-08-07 14:22:37 -070063#include "Scheduler/VSyncModulator.h"
Peiyong Lin2acb7d42019-01-14 17:22:27 -080064#include "SurfaceFlingerFactory.h"
65#include "SurfaceInterceptor.h"
66#include "SurfaceTracing.h"
67#include "TransactionCompletedThread.h"
Mathias Agopian86303202012-07-24 22:46:10 -070068
Dan Stozae77c7662016-05-13 11:37:28 -070069#include <map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080070#include <mutex>
71#include <queue>
Dominik Laskowski075d3172018-05-24 15:50:06 -070072#include <set>
Dan Stozae77c7662016-05-13 11:37:28 -070073#include <string>
Steven Thomasb02664d2017-07-26 18:48:28 -070074#include <thread>
Dominik Laskowski075d3172018-05-24 15:50:06 -070075#include <unordered_map>
Brian Anderson0a61b0c2016-12-07 14:55:56 -080076#include <utility>
Dan Stozae77c7662016-05-13 11:37:28 -070077
chaviw1d044282017-09-27 12:19:28 -070078using namespace android::surfaceflinger;
79
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080080namespace android {
81
82// ---------------------------------------------------------------------------
83
84class Client;
chaviw13fdc492017-06-27 12:40:18 -070085class ColorLayer;
Lloyd Pique144e1162017-12-20 16:44:52 -080086class DisplayEventConnection;
Jamie Gennisd1700752013-10-14 12:22:52 -070087class EventControlThread;
Lloyd Pique144e1162017-12-20 16:44:52 -080088class EventThread;
Lloyd Pique12eb4232018-01-17 11:54:43 -080089class IGraphicBufferConsumer;
90class IGraphicBufferProducer;
Robert Carr720e5062018-07-30 17:45:14 -070091class IInputFlinger;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -070092class InjectVSyncSource;
Lloyd Pique144e1162017-12-20 16:44:52 -080093class Layer;
94class Surface;
David Sodman105b7dc2017-11-04 20:28:14 -070095class SurfaceFlingerBE;
Yiwei Zhang7e666a52018-11-15 13:33:42 -080096class TimeStats;
Lloyd Pique144e1162017-12-20 16:44:52 -080097class VSyncSource;
David Sodmanba340492018-08-05 21:51:33 -070098struct CompositionInfo;
Lloyd Pique144e1162017-12-20 16:44:52 -080099
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800100namespace impl {
101class EventThread;
102} // namespace impl
103
Peiyong Lin833074a2018-08-28 11:53:54 -0700104namespace renderengine {
Lloyd Pique144e1162017-12-20 16:44:52 -0800105class RenderEngine;
106}
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800107
chaviwa76b2712017-09-20 12:02:26 -0700108typedef std::function<void(const LayerVector::Visitor&)> TraverseLayersFunction;
109
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800110namespace dvr {
111class VrFlinger;
112} // namespace dvr
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800113
Lloyd Pique22098362018-09-13 11:46:49 -0700114namespace surfaceflinger {
115class NativeWindowSurface;
116} // namespace surfaceflinger
117
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800118// ---------------------------------------------------------------------------
119
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800120enum {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700121 eTransactionNeeded = 0x01,
122 eTraversalNeeded = 0x02,
123 eDisplayTransactionNeeded = 0x04,
Lloyd Piqued432a7c2018-03-23 16:05:31 -0700124 eDisplayLayerStackChanged = 0x08,
125 eTransactionMask = 0x0f,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800126};
127
Peiyong Lindd9b2ae2018-03-01 16:22:45 -0800128enum class DisplayColorSetting : int32_t {
129 MANAGED = 0,
130 UNMANAGED = 1,
131 ENHANCED = 2,
132};
133
Lloyd Pique99d3da52018-01-22 17:48:03 -0800134
David Sodman105b7dc2017-11-04 20:28:14 -0700135class SurfaceFlingerBE
136{
137public:
138 SurfaceFlingerBE();
139
David Sodmanbc815282017-11-05 18:57:52 -0800140 const std::string mHwcServiceName; // "default" for real use, something else for testing.
141
David Sodman73beded2017-11-15 11:56:06 -0800142 FenceTimeline mGlCompositionDoneTimeline;
143 FenceTimeline mDisplayTimeline;
David Sodmanbc815282017-11-05 18:57:52 -0800144
David Sodman99974d22017-11-28 12:04:33 -0800145 // protected by mCompositorTimingLock;
146 mutable std::mutex mCompositorTimingLock;
147 CompositorTiming mCompositorTiming;
Lloyd Piquefcd86612017-12-14 17:15:36 -0800148
David Sodman99974d22017-11-28 12:04:33 -0800149 // Only accessed from the main thread.
150 struct CompositePresentTime {
151 nsecs_t composite { -1 };
152 std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
153 };
154 std::queue<CompositePresentTime> mCompositePresentTimes;
155
David Sodman4a36e932017-11-07 14:29:47 -0800156 static const size_t NUM_BUCKETS = 8; // < 1-7, 7+
157 nsecs_t mFrameBuckets[NUM_BUCKETS];
158 nsecs_t mTotalTime;
159 std::atomic<nsecs_t> mLastSwapTime;
160
Alec Mouri86770e52018-09-24 22:40:58 +0000161 // Synchronization fence from a GL composition.
162 sp<Fence> flushFence = Fence::NO_FENCE;
163
David Sodmancbaf0832017-11-07 14:21:36 -0800164 // Double- vs. triple-buffering stats
165 struct BufferingStats {
166 BufferingStats()
167 : numSegments(0),
168 totalTime(0),
169 twoBufferTime(0),
170 doubleBufferedTime(0),
171 tripleBufferedTime(0) {}
172
173 size_t numSegments;
174 nsecs_t totalTime;
175
176 // "Two buffer" means that a third buffer was never used, whereas
177 // "double-buffered" means that on average the segment only used two
178 // buffers (though it may have used a third for some part of the
179 // segment)
180 nsecs_t twoBufferTime;
181 nsecs_t doubleBufferedTime;
182 nsecs_t tripleBufferedTime;
183 };
184 mutable Mutex mBufferingStatsMutex;
185 std::unordered_map<std::string, BufferingStats> mBufferingStats;
186
David Sodman105b7dc2017-11-04 20:28:14 -0700187 // The composer sequence id is a monotonically increasing integer that we
188 // use to differentiate callbacks from different hardware composer
189 // instances. Each hardware composer instance gets a different sequence id.
190 int32_t mComposerSequenceId;
David Sodmanba340492018-08-05 21:51:33 -0700191
Dominik Laskowski05275f12018-11-01 15:03:24 -0700192 std::map<wp<IBinder>, std::vector<CompositionInfo>> mCompositionInfo;
193 std::map<wp<IBinder>, std::vector<CompositionInfo>> mEndOfFrameCompositionInfo;
David Sodman105b7dc2017-11-04 20:28:14 -0700194};
195
196
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700197class SurfaceFlinger : public BnSurfaceComposer,
Vishnu Nair35798872017-10-06 16:00:36 -0700198 public PriorityDumper,
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700199 private IBinder::DeathRecipient,
Steven Thomasb02664d2017-07-26 18:48:28 -0700200 private HWC2::ComposerCallback
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800201{
202public:
David Sodman105b7dc2017-11-04 20:28:14 -0700203 SurfaceFlingerBE& getBE() { return mBE; }
204 const SurfaceFlingerBE& getBE() const { return mBE; }
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800205
Fabien Sanglard0cc19382017-03-06 11:54:40 -0800206 // This is the phase offset in nanoseconds of the software vsync event
207 // relative to the vsync event reported by HWComposer. The software vsync
208 // event is when SurfaceFlinger and Choreographer-based applications run each
209 // frame.
210 //
211 // This phase offset allows adjustment of the minimum latency from application
212 // wake-up time (by Choreographer) to the time at which the resulting window
213 // image is displayed. This value may be either positive (after the HW vsync)
214 // or negative (before the HW vsync). Setting it to 0 will result in a lower
215 // latency bound of two vsync periods because the app and SurfaceFlinger
216 // will run just after the HW vsync. Setting it to a positive number will
217 // result in the minimum latency being:
218 //
219 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
220 //
221 // Note that reducing this latency makes it more likely for the applications
222 // to not have their window content image ready in time. When this happens
223 // the latency will end up being an additional vsync period, and animations
224 // will hiccup. Therefore, this latency should be tuned somewhat
225 // conservatively (or at least with awareness of the trade-off being made).
226 static int64_t vsyncPhaseOffsetNs;
227 static int64_t sfVsyncPhaseOffsetNs;
228
Fabien Sanglardcbf153b2017-03-10 17:57:12 -0800229 // If fences from sync Framework are supported.
230 static bool hasSyncFramework;
231
Fabien Sanglardc45a7d92017-03-14 13:24:22 -0700232 // The offset in nanoseconds to use when DispSync timestamps present fence
233 // signaling time.
234 static int64_t dispSyncPresentTimeOffset;
235
Fabien Sanglarda34ed632017-03-14 11:43:52 -0700236 // Some hardware can do RGB->YUV conversion more efficiently in hardware
237 // controlled by HWC than in hardware controlled by the video encoder.
238 // This instruct VirtualDisplaySurface to use HWC for such conversion on
239 // GL composition.
240 static bool useHwcForRgbToYuv;
241
Fabien Sanglardc8e387e2017-03-10 10:30:28 -0800242 // Maximum dimension supported by HWC for virtual display.
243 // Equal to min(max_height, max_width).
244 static uint64_t maxVirtualDisplaySize;
245
Fabien Sanglard1971b632017-03-10 14:50:03 -0800246 // Controls the number of buffers SurfaceFlinger will allocate for use in
247 // FramebufferSurface
248 static int64_t maxFrameBufferAcquiredBuffers;
249
Peiyong Lin13effd12018-07-24 17:01:47 -0700250 // Indicate if a device has wide color gamut display. This is typically
251 // found on devices with wide color gamut (e.g. Display-P3) display.
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600252 static bool hasWideColorDisplay;
253
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700254 static int primaryDisplayOrientation;
255
Peiyong Lin13effd12018-07-24 17:01:47 -0700256 // Indicate if device wants color management on its display.
257 static bool useColorManagement;
258
Peiyong Linb3839ad2018-09-05 15:37:19 -0700259 static bool useContextPriority;
260
Peiyong Lin0256f722018-08-31 15:45:10 -0700261 // The data space and pixel format that SurfaceFlinger expects hardware composer
262 // to composite efficiently. Meaning under most scenarios, hardware composer
263 // will accept layers with the data space and pixel format.
Peiyong Linc6780972018-10-28 15:24:08 -0700264 static ui::Dataspace defaultCompositionDataspace;
265 static ui::PixelFormat defaultCompositionPixelFormat;
266
267 // The data space and pixel format that SurfaceFlinger expects hardware composer
268 // to composite efficiently for wide color gamut surfaces. Meaning under most scenarios,
269 // hardware composer will accept layers with the data space and pixel format.
270 static ui::Dataspace wideColorGamutCompositionDataspace;
271 static ui::PixelFormat wideColorGamutCompositionPixelFormat;
Peiyong Lin0256f722018-08-31 15:45:10 -0700272
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700273 static char const* getServiceName() ANDROID_API {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700274 return "SurfaceFlinger";
275 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800276
Lloyd Piqueac648ee2018-01-17 13:42:24 -0800277 struct SkipInitializationTag {};
278 static constexpr SkipInitializationTag SkipInitialization;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700279 SurfaceFlinger(surfaceflinger::Factory&, SkipInitializationTag) ANDROID_API;
280 explicit SurfaceFlinger(surfaceflinger::Factory&) ANDROID_API;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800281
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700282 // must be called before clients can connect
283 void init() ANDROID_API;
284
285 // starts SurfaceFlinger main loop in the current thread
286 void run() ANDROID_API;
287
Mathias Agopian86303202012-07-24 22:46:10 -0700288 enum {
289 EVENT_VSYNC = HWC_EVENT_VSYNC
290 };
291
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700292 // post an asynchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700293 status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800294
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700295 // post a synchronous message to the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700296 status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800297
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700298 // force full composition on all displays
299 void repaintEverything();
Mathias Agopianbf2c6a62010-12-10 16:22:31 -0800300
Ana Krulec7d1d6832018-12-27 11:10:09 -0800301 // force full composition on all displays without resetting the scheduler idle timer.
302 void repaintEverythingForHWC();
303
Lloyd Pique90c115d2018-09-18 21:39:42 -0700304 surfaceflinger::Factory& getFactory() { return mFactory; }
305
Lloyd Pique70d91362018-10-18 16:02:55 -0700306 // The CompositionEngine encapsulates all composition related interfaces and actions.
307 compositionengine::CompositionEngine& getCompositionEngine() const;
308
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700309 // returns the default Display
Tomasz Wasilczyk8722a312017-04-13 19:14:30 +0000310 sp<const DisplayDevice> getDefaultDisplayDevice() const {
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700311 Mutex::Autolock _l(mStateLock);
312 return getDefaultDisplayDeviceLocked();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700313 }
Mathias Agopianb60314a2012-04-10 22:09:54 -0700314
Dan Stoza436ccf32018-06-21 12:10:12 -0700315 // Obtains a name from the texture pool, or, if the pool is empty, posts a
316 // synchronous message to the main thread to obtain one on the fly
317 uint32_t getNewTexture();
318
Mathias Agopian86303202012-07-24 22:46:10 -0700319 // utility function to delete a texture on the main thread
Mathias Agopian3f844832013-08-07 21:24:32 -0700320 void deleteTextureAsync(uint32_t texture);
Mathias Agopian86303202012-07-24 22:46:10 -0700321
Mathias Agopian86303202012-07-24 22:46:10 -0700322 // enable/disable h/w composer event
323 // TODO: this should be made accessible only to EventThread
Dominik Laskowski075d3172018-05-24 15:50:06 -0700324 void setVsyncEnabled(EventThread::DisplayType displayType, bool enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700325
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700326 // called on the main thread by MessageQueue when an internal message
327 // is received
328 // TODO: this should be made accessible only to MessageQueue
329 void onMessageReceived(int32_t what);
Mathias Agopian3094df32012-06-18 18:06:45 -0700330
Mathias Agopiancb558572012-10-04 15:58:54 -0700331 // for debugging only
332 // TODO: this should be made accessible only to HWComposer
Dominik Laskowski075d3172018-05-24 15:50:06 -0700333 const Vector<sp<Layer>>& getLayerSortedByZForHwcDisplay(DisplayId displayId);
Mathias Agopiancb558572012-10-04 15:58:54 -0700334
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700335 renderengine::RenderEngine& getRenderEngine() const;
Jesse Hall29c3f352013-05-21 15:36:55 -0700336
Robert Carr0d480722017-01-10 16:42:54 -0800337 bool authenticateSurfaceTextureLocked(
338 const sp<IGraphicBufferProducer>& bufferProducer) const;
339
Robert Carr2e102c92018-10-23 12:11:15 -0700340 inline void onLayerCreated() { mNumLayers++; }
341 inline void onLayerDestroyed() { mNumLayers--; }
342
Marissa Walle2ffb422018-10-12 11:33:52 -0700343 TransactionCompletedThread& getTransactionCompletedThread() {
344 return mTransactionCompletedThread;
345 }
346
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700347private:
Mathias Agopian96f08192010-06-02 23:28:45 -0700348 friend class Client;
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800349 friend class DisplayEventConnection;
Lloyd Pique0fcde1b2017-12-20 16:50:21 -0800350 friend class impl::EventThread;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800351 friend class Layer;
David Sodman0c69cad2017-08-21 12:12:51 -0700352 friend class BufferLayer;
Marissa Wallfd668622018-05-10 10:21:13 -0700353 friend class BufferQueueLayer;
Marissa Wall61c58622018-07-18 10:12:20 -0700354 friend class BufferStateLayer;
Dan Stozab9b08832014-03-13 11:55:57 -0700355 friend class MonitoredProducer;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800356
Lloyd Piquef58625d2017-12-19 13:22:33 -0800357 // For unit tests
358 friend class TestableSurfaceFlinger;
359
Jamie Gennis6547ff42013-07-16 20:12:42 -0700360 // This value is specified in number of frames. Log frame stats at most
361 // every half hour.
362 enum { LOG_FRAME_STATS_PERIOD = 30*60*60 };
363
Dan Stoza7d89d062015-04-30 13:29:25 -0700364 static const size_t MAX_LAYERS = 4096;
365
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700366 // We're reference counted, never destroy SurfaceFlinger directly
367 virtual ~SurfaceFlinger();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800368
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700369 /* ------------------------------------------------------------------------
370 * Internal data structures
371 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800372
Robert Carr2047fae2016-11-28 14:09:09 -0800373 class State {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800374 public:
chaviwfd462612018-05-31 16:11:27 -0700375 explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
Dan Stoza412903f2017-04-27 13:42:17 -0700376 State& operator=(const State& other) {
377 // We explicitly don't copy stateSet so that, e.g., mDrawingState
378 // always uses the Drawing StateSet.
379 layersSortedByZ = other.layersSortedByZ;
380 displays = other.displays;
Chia-I Wu28f320b2018-05-03 11:02:56 -0700381 colorMatrixChanged = other.colorMatrixChanged;
382 if (colorMatrixChanged) {
383 colorMatrix = other.colorMatrix;
384 }
Dan Stoza412903f2017-04-27 13:42:17 -0700385 return *this;
386 }
387
388 const LayerVector::StateSet stateSet = LayerVector::StateSet::Invalid;
Mathias Agopian92a979a2012-08-02 18:32:23 -0700389 LayerVector layersSortedByZ;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700390 DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays;
Robert Carr2047fae2016-11-28 14:09:09 -0800391
Chia-I Wu28f320b2018-05-03 11:02:56 -0700392 bool colorMatrixChanged = true;
393 mat4 colorMatrix;
394
Dan Stoza412903f2017-04-27 13:42:17 -0700395 void traverseInZOrder(const LayerVector::Visitor& visitor) const;
396 void traverseInReverseZOrder(const LayerVector::Visitor& visitor) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800397 };
398
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700399 /* ------------------------------------------------------------------------
400 * IBinder interface
401 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800402 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
403 status_t dump(int fd, const Vector<String16>& args) override { return priorityDump(fd, args); }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800404
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700405 /* ------------------------------------------------------------------------
406 * ISurfaceComposer interface
407 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800408 sp<ISurfaceComposerClient> createConnection() override;
409 sp<IBinder> createDisplay(const String8& displayName, bool secure) override;
410 void destroyDisplay(const sp<IBinder>& displayToken) override;
411 sp<IBinder> getBuiltInDisplay(int32_t id) override;
412 void setTransactionState(const Vector<ComposerState>& state,
413 const Vector<DisplayState>& displays, uint32_t flags,
414 const sp<IBinder>& applyToken,
415 const InputWindowCommands& inputWindowCommands) override;
416 void bootFinished() override;
417 bool authenticateSurfaceTexture(
418 const sp<IGraphicBufferProducer>& bufferProducer) const override;
419 status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override;
420 sp<IDisplayEventConnection> createDisplayEventConnection(
421 ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp) override;
422 status_t captureScreen(const sp<IBinder>& displayToken, sp<GraphicBuffer>* outBuffer,
423 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
424 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
425 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) override;
426 status_t captureLayers(const sp<IBinder>& parentHandle, sp<GraphicBuffer>* outBuffer,
427 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
428 const Rect& sourceCrop, float frameScale, bool childrenOnly) override;
429 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
430 status_t getDisplayConfigs(const sp<IBinder>& displayToken,
431 Vector<DisplayInfo>* configs) override;
432 int getActiveConfig(const sp<IBinder>& displayToken) override;
433 status_t getDisplayColorModes(const sp<IBinder>& displayToken,
434 Vector<ui::ColorMode>* configs) override;
435 ui::ColorMode getActiveColorMode(const sp<IBinder>& displayToken) override;
436 status_t setActiveColorMode(const sp<IBinder>& displayToken, ui::ColorMode colorMode) override;
437 void setPowerMode(const sp<IBinder>& displayToken, int mode) override;
438 status_t setActiveConfig(const sp<IBinder>& displayToken, int id) override;
439 status_t clearAnimationFrameStats() override;
440 status_t getAnimationFrameStats(FrameStats* outStats) const override;
441 status_t getHdrCapabilities(const sp<IBinder>& displayToken,
442 HdrCapabilities* outCapabilities) const override;
443 status_t enableVSyncInjections(bool enable) override;
444 status_t injectVSync(nsecs_t when) override;
445 status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const override;
446 status_t getColorManagement(bool* outGetColorManagement) const override;
Peiyong Linc6780972018-10-28 15:24:08 -0700447 status_t getCompositionPreference(ui::Dataspace* outDataspace, ui::PixelFormat* outPixelFormat,
448 ui::Dataspace* outWideColorGamutDataspace,
449 ui::PixelFormat* outWideColorGamutPixelFormat) const override;
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800450 status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
451 ui::PixelFormat* outFormat,
452 ui::Dataspace* outDataspace,
453 uint8_t* outComponentMask) const override;
454 status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
455 uint8_t componentMask,
456 uint64_t maxFrames) const override;
457 status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
458 uint64_t timestamp,
459 DisplayedFrameStats* outStats) const override;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800460 status_t getProtectedContentSupport(bool* outSupported) const override;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700461
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700462 /* ------------------------------------------------------------------------
463 * DeathRecipient interface
464 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800465 void binderDied(const wp<IBinder>& who) override;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800466
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700467 /* ------------------------------------------------------------------------
Mathias Agopian4f4f0942013-08-19 17:26:18 -0700468 * RefBase interface
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700469 */
Peiyong Lin2acb7d42019-01-14 17:22:27 -0800470 void onFirstRef() override;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800471
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700472 /* ------------------------------------------------------------------------
Steven Thomasb02664d2017-07-26 18:48:28 -0700473 * HWC2::ComposerCallback / HWComposer::EventHandler interface
Mathias Agopian86303202012-07-24 22:46:10 -0700474 */
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700475 void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Steven Thomasb02664d2017-07-26 18:48:28 -0700476 int64_t timestamp) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700477 void onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
Lloyd Pique715a2c12017-12-14 17:18:08 -0800478 HWC2::Connection connection) override;
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700479 void onRefreshReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId) override;
Mathias Agopian86303202012-07-24 22:46:10 -0700480
481 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700482 * Message handling
483 */
484 void waitForEvent();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700485 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700486 void signalTransaction();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700487 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700488 void signalLayerUpdate();
489 void signalRefresh();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800490
Andy McFadden13a082e2012-08-24 10:16:42 -0700491 // called on the main thread in response to initializeDisplays()
492 void onInitializeDisplays();
Ana Krulec7d1d6832018-12-27 11:10:09 -0800493 // setActiveConfigInternal() posted on a main thread for async execution
494 status_t setActiveConfigAsync(const sp<IBinder>& displayToken, int mode);
Michael Lentine6c9e34a2014-07-14 13:48:55 -0700495 // called on the main thread in response to setActiveConfig()
Ana Krulec7d1d6832018-12-27 11:10:09 -0800496 void setActiveConfigInternal(const sp<IBinder>& displayToken, int mode);
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700497 // called on the main thread in response to setPowerMode()
Dominik Laskowskie9774092018-12-11 10:04:24 -0800498 void setPowerModeInternal(const sp<DisplayDevice>& display, int mode);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800499
Michael Wright28f24d02016-07-12 13:30:53 -0700500 // Called on the main thread in response to setActiveColorMode()
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700501 void setActiveColorModeInternal(const sp<DisplayDevice>& display, ui::ColorMode colorMode,
502 ui::Dataspace dataSpace, ui::RenderIntent renderIntent);
Michael Wright28f24d02016-07-12 13:30:53 -0700503
Dan Stoza6b9454d2014-11-07 16:00:59 -0800504 // Returns whether the transaction actually modified any state
505 bool handleMessageTransaction();
506
507 // Returns whether a new buffer has been latched (see handlePageFlip())
508 bool handleMessageInvalidate();
509
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700510 void handleMessageRefresh();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700511
Mathias Agopian87baae12012-07-31 12:38:26 -0700512 void handleTransaction(uint32_t transactionFlags);
513 void handleTransactionLocked(uint32_t transactionFlags);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800514
Robert Carr720e5062018-07-30 17:45:14 -0700515 void updateInputWindows();
chaviwfbe5d9c2018-12-26 12:23:37 -0800516 void executeInputWindowCommands();
Riley Andrews03414a12014-07-01 14:22:59 -0700517 void updateCursorAsync();
518
Dan Stoza6b9454d2014-11-07 16:00:59 -0800519 /* handlePageFlip - latch a new buffer if available and compute the dirty
520 * region. Returns whether a new buffer has been latched, i.e., whether it
521 * is necessary to perform a refresh during this vsync.
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700522 */
Dan Stoza6b9454d2014-11-07 16:00:59 -0800523 bool handlePageFlip();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800524
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700525 /* ------------------------------------------------------------------------
526 * Transactions
527 */
Marissa Wall713b63f2018-10-17 15:42:43 -0700528 void applyTransactionState(const Vector<ComposerState>& state,
chaviw273171b2018-12-26 11:46:30 -0800529 const Vector<DisplayState>& displays, uint32_t flags,
530 const InputWindowCommands& inputWindowCommands) REQUIRES(mStateLock);
Marissa Wall713b63f2018-10-17 15:42:43 -0700531 bool flushTransactionQueues();
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700532 uint32_t getTransactionFlags(uint32_t flags);
Fabien Sanglardc8251eb2016-12-07 13:59:48 -0800533 uint32_t peekTransactionFlags();
Steven Thomas6d8110b2017-08-31 18:24:21 -0700534 // Can only be called from the main thread or with mStateLock held
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700535 uint32_t setTransactionFlags(uint32_t flags);
Ana Krulec7ecce8c2018-10-12 13:44:41 -0700536 uint32_t setTransactionFlags(uint32_t flags, Scheduler::TransactionStart transactionStart);
chaviw61626f22018-11-15 16:26:27 -0800537 void latchAndReleaseBuffer(const sp<Layer>& layer);
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700538 void commitTransaction();
chaviwca27f252018-02-06 16:46:39 -0800539 bool containsAnyInvalidClientState(const Vector<ComposerState>& states);
Marissa Wall713b63f2018-10-17 15:42:43 -0700540 bool composerStateContainsUnsignaledFences(const Vector<ComposerState>& states);
chaviwca27f252018-02-06 16:46:39 -0800541 uint32_t setClientStateLocked(const ComposerState& composerState);
Mathias Agopiane57f2922012-08-09 16:29:12 -0700542 uint32_t setDisplayStateLocked(const DisplayState& s);
chaviw273171b2018-12-26 11:46:30 -0800543 uint32_t addInputWindowCommands(const InputWindowCommands& inputWindowCommands);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800544
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700545 /* ------------------------------------------------------------------------
546 * Layer management
547 */
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700548 status_t createLayer(const String8& name, const sp<Client>& client,
549 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
rongliucfb187b2018-03-14 12:26:23 -0700550 int32_t windowType, int32_t ownerUid, sp<IBinder>* handle,
Albert Chaulk479c60c2017-01-27 14:21:34 -0500551 sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800552
Marissa Wallfd668622018-05-10 10:21:13 -0700553 status_t createBufferQueueLayer(const sp<Client>& client, const String8& name, uint32_t w,
554 uint32_t h, uint32_t flags, PixelFormat& format,
555 sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
556 sp<Layer>* outLayer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800557
Marissa Wall61c58622018-07-18 10:12:20 -0700558 status_t createBufferStateLayer(const sp<Client>& client, const String8& name, uint32_t w,
559 uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
560 sp<Layer>* outLayer);
561
chaviw13fdc492017-06-27 12:40:18 -0700562 status_t createColorLayer(const sp<Client>& client, const String8& name,
Mathias Agopian4d9b8222013-03-12 17:11:48 -0700563 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
David Sodman0c69cad2017-08-21 12:12:51 -0700564 sp<Layer>* outLayer);
Mathias Agopian74c40c02010-09-29 13:02:36 -0700565
Robert Carr6b3f6c52018-08-13 13:05:17 -0700566 status_t createContainerLayer(const sp<Client>& client, const String8& name,
567 uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
568 sp<Layer>* outLayer);
569
Cody Northropbc755282017-03-31 12:00:08 -0600570 String8 getUniqueLayerName(const String8& name);
571
Rob Carr4bba3702018-10-08 21:53:30 +0000572 // called when all clients have released all their references to
573 // this layer meaning it is entirely safe to destroy all
574 // resources associated to this layer.
Robert Carr695d5282018-12-18 15:27:58 -0800575 void onHandleDestroyed(sp<Layer>& layer);
Robert Carr6fb1a7e2018-12-11 12:07:25 -0800576 void markLayerPendingRemovalLocked(const sp<Layer>& layer);
Mathias Agopiana4912602012-07-12 14:25:33 -0700577
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700578 // add a layer to SurfaceFlinger
Dan Stoza7d89d062015-04-30 13:29:25 -0700579 status_t addClientLayer(const sp<Client>& client,
Mathias Agopian67106042013-03-14 19:18:13 -0700580 const sp<IBinder>& handle,
581 const sp<IGraphicBufferProducer>& gbc,
Robert Carr1f0a16a2016-10-24 16:27:39 -0700582 const sp<Layer>& lbc,
Robert Carrb89ea9d2018-12-10 13:01:14 -0800583 const sp<Layer>& parent,
584 bool addToCurrentState);
Mathias Agopianf1d8e872009-04-20 19:39:12 -0700585
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700586 /* ------------------------------------------------------------------------
587 * Boot animation, on/off animations and screen capture
588 */
Mathias Agopianbb641242010-05-18 17:06:55 -0700589
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700590 void startBootAnim();
Mathias Agopian96f08192010-06-02 23:28:45 -0700591
chaviwa76b2712017-09-20 12:02:26 -0700592 void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Chia-I Wu1be50b52018-08-29 10:44:48 -0700593 bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700594 status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700595 sp<GraphicBuffer>* outBuffer, const ui::PixelFormat reqPixelFormat,
chaviwa76b2712017-09-20 12:02:26 -0700596 bool useIdentityTransform);
chaviwa76b2712017-09-20 12:02:26 -0700597 status_t captureScreenImplLocked(const RenderArea& renderArea,
598 TraverseLayersFunction traverseLayers,
599 ANativeWindowBuffer* buffer, bool useIdentityTransform,
Robert Carr03480e22018-01-04 16:02:06 -0800600 bool forSystem, int* outSyncFd);
chaviw0e3479f2018-09-10 16:49:30 -0700601 void traverseLayersInDisplay(const sp<const DisplayDevice>& display,
602 const LayerVector::Visitor& visitor);
Mathias Agopianabe815d2013-03-19 22:22:21 -0700603
Lloyd Pique90c115d2018-09-18 21:39:42 -0700604 sp<StartPropertySetThread> mStartPropertySetThread;
Wei Wangb254fa32017-01-31 17:43:23 -0800605
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700606 /* ------------------------------------------------------------------------
Romain Guy11d63f42017-07-20 12:47:14 -0700607 * Properties
608 */
609 void readPersistentProperties();
610
611 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700612 * EGL
613 */
Mathias Agopian875d8e12013-06-07 15:35:48 -0700614 size_t getMaxTextureSize() const;
615 size_t getMaxViewportDims() const;
Mathias Agopiana4912602012-07-12 14:25:33 -0700616
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700617 /* ------------------------------------------------------------------------
Mathias Agopian87baae12012-07-31 12:38:26 -0700618 * Display and layer stack management
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700619 */
Andy McFadden13a082e2012-08-24 10:16:42 -0700620 // called when starting, or restarting after system_server death
621 void initializeDisplays();
622
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700623 sp<const DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) const {
624 Mutex::Autolock _l(mStateLock);
625 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700626 }
627
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700628 sp<DisplayDevice> getDisplayDevice(const wp<IBinder>& displayToken) {
629 Mutex::Autolock _l(mStateLock);
630 return getDisplayDeviceLocked(displayToken);
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700631 }
632
633 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700634 sp<const DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) const {
635 return const_cast<SurfaceFlinger*>(this)->getDisplayDeviceLocked(displayToken);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700636 }
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700637
638 // NOTE: can only be called from the main thread or with mStateLock held
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700639 sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) {
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700640 const auto it = mDisplays.find(displayToken);
641 return it == mDisplays.end() ? nullptr : it->second;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700642 }
Mathias Agopian99b49842011-06-27 16:05:52 -0700643
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700644 sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const {
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700645 return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked();
Stephen Kiazyk7d3dcb92017-04-05 16:46:49 -0700646 }
647
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700648 sp<DisplayDevice> getDefaultDisplayDeviceLocked() {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700649 if (const auto token = getInternalDisplayToken()) {
650 return getDisplayDeviceLocked(token);
651 }
652 return nullptr;
Michael Wright28f24d02016-07-12 13:30:53 -0700653 }
654
Mathias Agopian87baae12012-07-31 12:38:26 -0700655 // mark a region of a layer stack dirty. this updates the dirty
656 // region of all screens presenting this layer stack.
Chia-I Wuab0c3192017-08-01 11:29:00 -0700657 void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty);
Mathias Agopian87baae12012-07-31 12:38:26 -0700658
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700659 /* ------------------------------------------------------------------------
Mathias Agopian86303202012-07-24 22:46:10 -0700660 * H/W composer
661 */
662
Lloyd Pique441d5042018-10-18 16:49:51 -0700663 // The current hardware composer interface.
664 //
665 // The following thread safety rules apply when accessing mHwc, either
666 // directly or via getHwComposer():
667 //
668 // 1. When recreating mHwc, acquire mStateLock. We currently recreate mHwc
669 // only when switching into and out of vr. Recreating mHwc must only be
670 // done on the main thread.
671 //
672 // 2. When accessing mHwc on the main thread, it's not necessary to acquire
673 // mStateLock.
674 //
675 // 3. When accessing mHwc on a thread other than the main thread, we always
676 // need to acquire mStateLock. This is because the main thread could be
677 // in the process of destroying the current mHwc instance.
678 //
679 // The above thread safety rules only apply to SurfaceFlinger.cpp. In
680 // SurfaceFlinger_hwc1.cpp we create mHwc at surface flinger init and never
681 // destroy it, so it's always safe to access mHwc from any thread without
682 // acquiring mStateLock.
683 HWComposer& getHwComposer() const;
Mathias Agopian86303202012-07-24 22:46:10 -0700684
Mathias Agopian888c8222012-08-04 21:10:38 -0700685 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700686 * Compositing
687 */
688 void invalidateHwcGeometry();
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700689 void computeVisibleRegions(const sp<const DisplayDevice>& display, Region& dirtyRegion,
690 Region& opaqueRegion);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700691
David Sodman2b406362017-12-15 13:33:47 -0800692 void preComposition();
693 void postComposition();
Dominik Laskowskif654d572018-12-20 11:03:06 -0800694 void getCompositorTiming(CompositorTiming* compositorTiming);
Ana Krulece588e312018-09-18 12:32:24 -0700695 void updateCompositorTiming(const DisplayStatInfo& stats, nsecs_t compositeTime,
696 std::shared_ptr<FenceTime>& presentFenceTime);
697 void setCompositorTimingSnapped(const DisplayStatInfo& stats,
698 nsecs_t compositeToPresentLatency);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700699 void rebuildLayerStacks();
Courtney Goeltzenleuchter5d943892017-03-22 13:46:46 -0600700
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700701 ui::Dataspace getBestDataspace(const sp<const DisplayDevice>& display,
Peiyong Lin136fbbc2018-04-17 15:09:44 -0700702 ui::Dataspace* outHdrDataSpace) const;
703
704 // Returns the appropriate ColorMode, Dataspace and RenderIntent for the
705 // DisplayDevice. The function only returns the supported ColorMode,
706 // Dataspace and RenderIntent.
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700707 void pickColorMode(const sp<DisplayDevice>& display, ui::ColorMode* outMode,
708 ui::Dataspace* outDataSpace, ui::RenderIntent* outRenderIntent) const;
Romain Guy0147a172017-06-01 13:53:56 -0700709
David Sodman79bba0e2018-08-05 18:07:49 -0700710 void calculateWorkingSet();
David Sodman2b406362017-12-15 13:33:47 -0800711 /*
712 * beginFrame - This function handles any pre-frame processing that needs to be
713 * prior to any CompositionInfo handling and is not dependent on data in
714 * CompositionInfo
715 */
David Sodmanfa9b2af2017-12-24 13:28:59 -0800716 void beginFrame(const sp<DisplayDevice>& display);
David Sodman2b406362017-12-15 13:33:47 -0800717 /* prepareFrame - This function will call into the DisplayDevice to prepare a
718 * frame after CompositionInfo has been programmed. This provides a mechanism
719 * to prepare the hardware composer
720 */
David Sodmanfa9b2af2017-12-24 13:28:59 -0800721 void prepareFrame(const sp<DisplayDevice>& display);
722 void doComposition(const sp<DisplayDevice>& display, bool repainEverything);
723 void doDebugFlashRegions(const sp<DisplayDevice>& display, bool repaintEverything);
Adrian Roos1e1a1282017-11-01 19:05:31 +0100724 void doTracing(const char* where);
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800725 void logLayerStats();
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800726 void doDisplayComposition(const sp<DisplayDevice>& display, const Region& dirtyRegion);
Michael Lentine3f121fc2014-10-01 11:17:28 -0700727
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700728 // This fails if using GL and the surface has been destroyed.
Alec Mouri0a9c7b82018-11-16 13:05:25 -0800729 bool doComposeSurfaces(const sp<DisplayDevice>& display);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700730
David Sodmanfa9b2af2017-12-24 13:28:59 -0800731 void postFramebuffer(const sp<DisplayDevice>& display);
732 void postFrame();
Chia-I Wu28e3a252018-09-07 12:05:02 -0700733 void drawWormhole(const Region& region) const;
Mathias Agopian4da75192010-08-10 17:19:56 -0700734
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700735 /* ------------------------------------------------------------------------
Jamie Gennis0bceb842012-08-23 20:19:38 -0700736 * Display management
737 */
Dominik Laskowski7e045462018-05-30 13:02:02 -0700738 sp<DisplayDevice> setupNewDisplayDeviceInternal(const wp<IBinder>& displayToken,
Dominik Laskowski075d3172018-05-24 15:50:06 -0700739 const std::optional<DisplayId>& displayId,
Lloyd Pique99d3da52018-01-22 17:48:03 -0800740 const DisplayDeviceState& state,
741 const sp<DisplaySurface>& dispSurface,
742 const sp<IGraphicBufferProducer>& producer);
Lloyd Pique347200f2017-12-14 17:00:15 -0800743 void processDisplayChangesLocked();
Lloyd Piqueba04e622017-12-14 17:11:26 -0800744 void processDisplayHotplugEventsLocked();
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700745
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700746 /* ------------------------------------------------------------------------
747 * VSync
748 */
Brian Anderson0a61b0c2016-12-07 14:55:56 -0800749 void enableHardwareVsync();
750 void resyncToHardwareVsync(bool makeAvailable);
751 void disableHardwareVsync(bool makeUnavailable);
Robert Carr1f0a16a2016-10-24 16:27:39 -0700752
Ana Krulec7d1d6832018-12-27 11:10:09 -0800753 // Sets the refresh rate to newFps by switching active configs, if they are available for
754 // the desired refresh rate.
755 void setRefreshRateTo(float newFps);
Jamie Gennis0bceb842012-08-23 20:19:38 -0700756
Dominik Laskowskif654d572018-12-20 11:03:06 -0800757 // Stores per-display state about VSYNC.
758 struct VsyncState {
759 explicit VsyncState(SurfaceFlinger& flinger) : flinger(flinger) {}
760
761 void resync();
762
763 SurfaceFlinger& flinger;
764 nsecs_t lastResyncTime = 0;
765 };
766
767 const std::shared_ptr<VsyncState> mPrimaryVsyncState{std::make_shared<VsyncState>(*this)};
768
769 auto makeResyncCallback() {
770 std::weak_ptr<VsyncState> ptr = mPrimaryVsyncState;
771 return [ptr]() {
772 if (const auto vsync = ptr.lock()) {
773 vsync->resync();
774 }
775 };
776 }
777
Jamie Gennis0bceb842012-08-23 20:19:38 -0700778 /* ------------------------------------------------------------------------
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700779 * Debugging & dumpsys
780 */
Vishnu Nair35798872017-10-06 16:00:36 -0700781public:
Vishnu Nair6a408532017-10-24 09:11:27 -0700782 status_t dumpCritical(int fd, const Vector<String16>& /*args*/, bool asProto) {
783 return doDump(fd, Vector<String16>(), asProto);
Vishnu Nair35798872017-10-06 16:00:36 -0700784 }
785
Vishnu Nair6a408532017-10-24 09:11:27 -0700786 status_t dumpAll(int fd, const Vector<String16>& args, bool asProto) {
787 return doDump(fd, args, asProto);
788 }
789
Vishnu Nair35798872017-10-06 16:00:36 -0700790private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700791 sp<IBinder> getPhysicalDisplayToken(DisplayId displayId) const {
792 const auto it = mPhysicalDisplayTokens.find(displayId);
793 return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
794 }
795
796 std::optional<DisplayId> getPhysicalDisplayId(const sp<IBinder>& displayToken) const {
797 for (const auto& [id, token] : mPhysicalDisplayTokens) {
798 if (token == displayToken) {
799 return id;
800 }
801 }
802 return {};
803 }
804
805 // TODO(b/74619554): Remove special cases for primary display.
806 sp<IBinder> getInternalDisplayToken() const {
807 const auto displayId = getInternalDisplayId();
808 return displayId ? getPhysicalDisplayToken(*displayId) : nullptr;
809 }
810
811 std::optional<DisplayId> getInternalDisplayId() const {
812 const auto hwcDisplayId = getHwComposer().getInternalHwcDisplayId();
813 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
814 }
815
816 // TODO(b/74619554): Remove special cases for external display.
817 std::optional<DisplayId> getExternalDisplayId() const {
818 const auto hwcDisplayId = getHwComposer().getExternalHwcDisplayId();
819 return hwcDisplayId ? getHwComposer().toPhysicalDisplayId(*hwcDisplayId) : std::nullopt;
820 }
821
Yiwei Zhang5434a782018-12-05 18:06:32 -0800822 void listLayersLocked(const Vector<String16>& args, size_t& index, std::string& result) const;
823 void dumpStatsLocked(const Vector<String16>& args, size_t& index, std::string& result) const;
824 void clearStatsLocked(const Vector<String16>& args, size_t& index, std::string& result);
825 void dumpAllLocked(const Vector<String16>& args, size_t& index, std::string& result) const;
Keun young Park63f165f2012-08-31 10:53:36 -0700826 bool startDdmConnection();
Yiwei Zhang5434a782018-12-05 18:06:32 -0800827 void appendSfConfigString(std::string& result) const;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800828
Jamie Gennis6547ff42013-07-16 20:12:42 -0700829 void logFrameStats();
830
Yiwei Zhang5434a782018-12-05 18:06:32 -0800831 void dumpStaticScreenStats(std::string& result) const;
Brian Andersond6927fb2016-07-23 23:37:30 -0700832 // Not const because each Layer needs to query Fences and cache timestamps.
Yiwei Zhang5434a782018-12-05 18:06:32 -0800833 void dumpFrameEventsLocked(std::string& result);
Dan Stozab90cf072015-03-05 11:05:59 -0800834
Dan Stozae77c7662016-05-13 11:37:28 -0700835 void recordBufferingStats(const char* layerName,
836 std::vector<OccupancyTracker::Segment>&& history);
Yiwei Zhang5434a782018-12-05 18:06:32 -0800837 void dumpBufferingStats(std::string& result) const;
838 void dumpDisplayIdentificationData(std::string& result) const;
839 void dumpWideColorInfo(std::string& result) const;
840 void dumpFrameCompositionInfo(std::string& result) const;
Jorim Jaggi8e0af362017-11-14 16:28:28 +0100841 LayersProto dumpProtoInfo(LayerVector::StateSet stateSet) const;
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700842 LayersProto dumpVisibleLayersProtoInfo(const DisplayDevice& display) const;
Dan Stozae77c7662016-05-13 11:37:28 -0700843
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800844 bool isLayerTripleBufferingDisabled() const {
845 return this->mLayerTripleBufferingDisabled;
846 }
Vishnu Nair6a408532017-10-24 09:11:27 -0700847 status_t doDump(int fd, const Vector<String16>& args, bool asProto);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800848
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800849 /* ------------------------------------------------------------------------
850 * VrFlinger
851 */
Steven Thomasb02664d2017-07-26 18:48:28 -0700852 void resetDisplayState();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800853
Steven Thomas050b2c82017-03-06 11:45:16 -0800854 // Check to see if we should handoff to vr flinger.
855 void updateVrFlinger();
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800856
Chia-I Wu28f320b2018-05-03 11:02:56 -0700857 void updateColorMatrixLocked();
858
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700859 /* ------------------------------------------------------------------------
860 * Attributes
861 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800862
Lloyd Pique90c115d2018-09-18 21:39:42 -0700863 surfaceflinger::Factory& mFactory;
864
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700865 // access must be protected by mStateLock
866 mutable Mutex mStateLock;
Dan Stoza412903f2017-04-27 13:42:17 -0700867 State mCurrentState{LayerVector::StateSet::Current};
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700868 std::atomic<int32_t> mTransactionFlags{0};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700869 Condition mTransactionCV;
Jamie Gennis2d5e2302012-10-15 18:24:43 -0700870 bool mTransactionPending;
871 bool mAnimTransactionPending;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700872 SortedVector< sp<Layer> > mLayersPendingRemoval;
Dan Stoza101d8dc2018-02-27 15:42:25 -0800873
Chia-I Wu28f320b2018-05-03 11:02:56 -0700874 // global color transform states
875 Daltonizer mDaltonizer;
876 float mGlobalSaturationFactor = 1.0f;
877 mat4 mClientColorMatrix;
878
Dan Stoza101d8dc2018-02-27 15:42:25 -0800879 // Can't be unordered_set because wp<> isn't hashable
880 std::set<wp<IBinder>> mGraphicBufferProducerList;
Dan Stoza0a0158c2018-03-16 13:38:54 -0700881 size_t mMaxGraphicBufferProducerListSize = MAX_LAYERS;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800882
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700883 // protected by mStateLock (but we could use another lock)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700884 bool mLayersRemoved;
Robert Carr1f0a16a2016-10-24 16:27:39 -0700885 bool mLayersAdded;
Mathias Agopianca4d3602011-05-19 15:38:14 -0700886
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700887 std::atomic<bool> mRepaintEverything{false};
Mathias Agopianca4d3602011-05-19 15:38:14 -0700888
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800889 // constant members (no synchronization needed for access)
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700890 nsecs_t mBootTime;
Mathias Agopianb4b17302013-03-20 18:36:41 -0700891 bool mGpuToCpuSupported;
Lloyd Piquee83f9312018-02-01 12:53:17 -0800892 std::unique_ptr<EventThread> mEventThread;
893 std::unique_ptr<EventThread> mSFEventThread;
894 std::unique_ptr<EventThread> mInjectorEventThread;
895 std::unique_ptr<VSyncSource> mEventThreadSource;
896 std::unique_ptr<VSyncSource> mSfEventThreadSource;
897 std::unique_ptr<InjectVSyncSource> mVSyncInjector;
Lloyd Pique755e3192018-01-31 16:46:15 -0800898 std::unique_ptr<EventControlThread> mEventControlThread;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700899 std::unordered_map<DisplayId, sp<IBinder>> mPhysicalDisplayTokens;
Mathias Agopian3094df32012-06-18 18:06:45 -0700900
Dan Stoza84d619e2018-03-28 17:07:36 -0700901 VSyncModulator mVsyncModulator;
902
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700903 // Can only accessed from the main thread, these members
904 // don't need synchronization
Dan Stoza412903f2017-04-27 13:42:17 -0700905 State mDrawingState{LayerVector::StateSet::Drawing};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700906 bool mVisibleRegionsDirty;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800907 bool mGeometryInvalid;
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800908 bool mAnimCompositionPending;
Dan Stoza9e56aa02015-11-02 13:00:03 -0800909 std::vector<sp<Layer>> mLayersWithQueuedFrames;
Dan Stoza05dacfb2016-07-01 13:33:38 -0700910 sp<Fence> mPreviousPresentFence = Fence::NO_FENCE;
911 bool mHadClientComposition = false;
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700912
Chia-I Wu14c9c7b2018-06-26 10:18:18 +0800913 enum class BootStage {
914 BOOTLOADER,
915 BOOTANIMATION,
916 FINISHED,
917 };
918 BootStage mBootStage;
919
Lloyd Piqueba04e622017-12-14 17:11:26 -0800920 struct HotplugEvent {
Dominik Laskowskia2edf612018-06-01 13:15:16 -0700921 hwc2_display_t hwcDisplayId;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800922 HWC2::Connection connection = HWC2::Connection::Invalid;
Lloyd Piqueba04e622017-12-14 17:11:26 -0800923 };
924 // protected by mStateLock
925 std::vector<HotplugEvent> mPendingHotplugEvents;
926
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700927 // this may only be written from the main thread with mStateLock held
928 // it may be read from other threads with mStateLock held
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700929 std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700930
931 // don't use a lock for these, we don't care
932 int mDebugRegion;
933 int mDebugDDMS;
934 int mDebugDisableHWC;
935 int mDebugDisableTransformHint;
936 volatile nsecs_t mDebugInSwapBuffers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700937 volatile nsecs_t mDebugInTransaction;
938 nsecs_t mLastTransactionTime;
David Sodmanfa9b2af2017-12-24 13:28:59 -0800939 nsecs_t mPostFramebufferTime;
Dan Stozaee44edd2015-03-23 15:50:23 -0700940 bool mForceFullDamage;
Dan Stozac5da2712016-07-20 15:38:12 -0700941 bool mPropagateBackpressure = true;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700942 std::unique_ptr<SurfaceInterceptor> mInterceptor{mFactory.createSurfaceInterceptor(this)};
Adrian Roos1e1a1282017-11-01 19:05:31 +0100943 SurfaceTracing mTracing;
Yiwei Zhang7124ad32018-02-21 13:02:45 -0800944 LayerStats mLayerStats;
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800945 std::unique_ptr<TimeStats> mTimeStats;
Fabien Sanglard642b23d2017-02-09 12:29:39 -0800946 bool mUseHwcVirtualDisplays = false;
Marissa Wallcfcdaa52018-05-21 15:45:59 -0700947 std::atomic<uint32_t> mFrameMissedCount{0};
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700948
Marissa Walle2ffb422018-10-12 11:33:52 -0700949 TransactionCompletedThread mTransactionCompletedThread;
950
Fabien Sanglard63a5fcd2016-12-29 15:13:07 -0800951 // Restrict layers to use two buffers in their bufferqueues.
952 bool mLayerTripleBufferingDisabled = false;
953
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700954 // these are thread safe
Lloyd Pique90c115d2018-09-18 21:39:42 -0700955 mutable std::unique_ptr<MessageQueue> mEventQueue{mFactory.createMessageQueue()};
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800956 FrameTracker mAnimFrameTracker;
Lloyd Pique41be5d22018-06-21 13:11:48 -0700957 std::unique_ptr<DispSync> mPrimaryDispSync;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700958
959 // protected by mDestroyedLayerLock;
960 mutable Mutex mDestroyedLayerLock;
Mathias Agopian13127d82013-03-05 17:47:11 -0800961 Vector<Layer const *> mDestroyedLayers;
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700962
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700963 // protected by mHWVsyncLock
964 Mutex mHWVsyncLock;
965 bool mPrimaryHWVsyncEnabled;
Jesse Hall948fe0c2013-10-14 12:56:09 -0700966 bool mHWVsyncAvailable;
David Sodman2b406362017-12-15 13:33:47 -0800967 nsecs_t mRefreshStartTime;
Jamie Gennisfaf77cc2013-07-30 15:10:32 -0700968
Dan Stoza2b6d38e2017-06-01 16:40:30 -0700969 std::atomic<bool> mRefreshPending{false};
970
Dan Stoza436ccf32018-06-21 12:10:12 -0700971 // We maintain a pool of pre-generated texture names to hand out to avoid
972 // layer creation needing to run on the main thread (which it would
973 // otherwise need to do to access RenderEngine).
974 std::mutex mTexturePoolMutex;
975 uint32_t mTexturePoolSize = 0;
976 std::vector<uint32_t> mTexturePool;
977
Marissa Wall713b63f2018-10-17 15:42:43 -0700978 struct IBinderHash {
979 std::size_t operator()(const sp<IBinder>& strongPointer) const {
980 return std::hash<IBinder*>{}(strongPointer.get());
981 }
982 };
983 struct TransactionState {
984 TransactionState(const Vector<ComposerState>& composerStates,
985 const Vector<DisplayState>& displayStates, uint32_t transactionFlags)
986 : states(composerStates), displays(displayStates), flags(transactionFlags) {}
987
988 Vector<ComposerState> states;
989 Vector<DisplayState> displays;
990 uint32_t flags;
991 };
992 std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IBinderHash> mTransactionQueues;
993
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700994 /* ------------------------------------------------------------------------
995 * Feature prototyping
996 */
997
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700998 bool mInjectVSyncs;
999
Dan Stozab90cf072015-03-05 11:05:59 -08001000 // Static screen stats
1001 bool mHasPoweredOff;
Dan Stozae77c7662016-05-13 11:37:28 -07001002
Robert Carr1f0a16a2016-10-24 16:27:39 -07001003 size_t mNumLayers;
1004
Fabien Sanglard6e8e98a2016-10-27 20:04:11 -07001005 // Verify that transaction is being called by an approved process:
1006 // either AID_GRAPHICS or AID_SYSTEM.
1007 status_t CheckTransactCodeCredentials(uint32_t code);
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -08001008
Steven Thomasb02664d2017-07-26 18:48:28 -07001009 std::unique_ptr<dvr::VrFlinger> mVrFlinger;
Steven Thomas050b2c82017-03-06 11:45:16 -08001010 std::atomic<bool> mVrFlingerRequestsDisplay;
1011 static bool useVrFlinger;
Steven Thomasb02664d2017-07-26 18:48:28 -07001012 std::thread::id mMainThreadId;
Romain Guy0147a172017-06-01 13:53:56 -07001013
Chia-I Wue0ec4312018-07-03 01:17:18 +08001014 DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::ENHANCED;
David Sodman105b7dc2017-11-04 20:28:14 -07001015
Peiyong Lin9d846a52018-11-05 13:18:20 -08001016 ui::Dataspace mDefaultCompositionDataspace;
1017 ui::Dataspace mWideColorGamutCompositionDataspace;
1018
David Sodman105b7dc2017-11-04 20:28:14 -07001019 SurfaceFlingerBE mBE;
Lloyd Pique70d91362018-10-18 16:02:55 -07001020 std::unique_ptr<compositionengine::CompositionEngine> mCompositionEngine;
Ana Krulec98b5b242018-08-10 15:03:23 -07001021
1022 bool mUseScheduler = false;
1023 std::unique_ptr<Scheduler> mScheduler;
1024 sp<Scheduler::ConnectionHandle> mAppConnectionHandle;
1025 sp<Scheduler::ConnectionHandle> mSfConnectionHandle;
Robert Carr720e5062018-07-30 17:45:14 -07001026
1027 sp<IInputFlinger> mInputFlinger;
chaviw273171b2018-12-26 11:46:30 -08001028
1029 InputWindowCommands mInputWindowCommands;
Romain Guy0147a172017-06-01 13:53:56 -07001030};
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001031}; // namespace android
1032
1033#endif // ANDROID_SURFACE_FLINGER_H