blob: 6d225e01807c3d5c14e272de7536cbf292194430 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2006 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 Laskowski3cb3d4e2019-11-21 11:14:45 -080017#pragma once
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080018
19#include <stdint.h>
20#include <sys/types.h>
21
Robert Carr866455f2019-04-02 16:28:26 -070022#include <binder/IBinder.h>
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070023#include <binder/IInterface.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080024
Marissa Wall3dad52d2019-03-22 14:03:19 -070025#include <gui/ITransactionCompletedListener.h>
26
Vishnu Nairb13bb952019-11-15 10:24:08 -080027#include <math/vec4.h>
28
Daniel Solomon42d04562019-01-20 21:03:19 -080029#include <ui/ConfigStoreTypes.h>
Marin Shalamanova524a092020-07-27 21:39:55 +020030#include <ui/DisplayId.h>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070031#include <ui/DisplayedFrameStats.h>
Svetoslavd85084b2014-03-20 10:28:31 -070032#include <ui/FrameStats.h>
Chavi Weingarten40482ff2017-11-30 01:51:40 +000033#include <ui/GraphicBuffer.h>
Peiyong Lin9f034472018-03-28 15:29:00 -070034#include <ui/GraphicTypes.h>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070035#include <ui/PixelFormat.h>
Dominik Laskowski718f9602019-11-09 20:01:35 -080036#include <ui/Rotation.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080037
Marissa Wall3dad52d2019-03-22 14:03:19 -070038#include <utils/Errors.h>
39#include <utils/RefBase.h>
40#include <utils/Timers.h>
41#include <utils/Vector.h>
42
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -080043#include <optional>
Robert Carr866455f2019-04-02 16:28:26 -070044#include <unordered_set>
Brian Anderson069b3652016-07-22 10:32:47 -070045#include <vector>
46
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080047namespace android {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080048
Marissa Wall947d34e2019-03-29 14:03:53 -070049struct client_cache_t;
Colin Crossa2362b42016-09-26 13:48:25 -070050struct ComposerState;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080051struct DisplayConfig;
Jesse Hall646f5412014-08-07 22:19:07 -070052struct DisplayInfo;
Lajos Molnare7bda062014-09-18 20:05:27 -070053struct DisplayStatInfo;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080054struct DisplayState;
chaviw273171b2018-12-26 11:46:30 -080055struct InputWindowCommands;
Kalle Raitaa099a242017-01-11 11:17:29 -080056class LayerDebugInfo;
Dan Stozac4f471e2016-03-24 09:31:08 -070057class HdrCapabilities;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080058class IDisplayEventConnection;
Mathias Agopian2b5dd402017-02-07 17:36:19 -080059class IGraphicBufferProducer;
60class ISurfaceComposerClient;
Dan Stoza84ab9372018-12-17 15:27:57 -080061class IRegionSamplingListener;
Dan Stozac1879002014-05-22 15:59:05 -070062class Rect;
Brian Anderson3890c392016-07-25 12:48:08 -070063enum class FrameEvent;
Mathias Agopiana67932f2011-04-20 14:20:59 -070064
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -080065namespace ui {
66
67struct DisplayState;
68
69} // namespace ui
70
Andy McFadden882e3a32013-01-08 16:06:15 -080071/*
72 * This class defines the Binder IPC interface for accessing various
73 * SurfaceFlinger features.
74 */
Mathias Agopian3165cc22012-08-08 19:42:09 -070075class ISurfaceComposer: public IInterface {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076public:
Colin Cross17576de2016-09-26 13:07:06 -070077 DECLARE_META_INTERFACE(SurfaceComposer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080078
Ady Abraham0a525092020-03-03 12:51:24 -080079 static constexpr size_t MAX_LAYERS = 4096;
80
Mathias Agopian3165cc22012-08-08 19:42:09 -070081 // flags for setTransactionState()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080082 enum {
Mathias Agopian3165cc22012-08-08 19:42:09 -070083 eSynchronous = 0x01,
Ady Abrahambf1349c2020-06-12 14:26:18 -070084 eAnimation = 0x02,
Dan Stoza84d619e2018-03-28 17:07:36 -070085
Ady Abrahambf1349c2020-06-12 14:26:18 -070086 // DEPRECATED - use eExplicitEarlyWakeup[Start|End]
87 eEarlyWakeup = 0x04,
88
89 // Explicit indication that this transaction and others to follow will likely result in a
90 // lot of layers being composed, and thus, SurfaceFlinger should wake-up earlier to avoid
91 // missing frame deadlines. In this case SurfaceFlinger will wake up at
92 // (sf vsync offset - debug.sf.early_phase_offset_ns). SurfaceFlinger will continue to be
93 // in the early configuration until it receives eExplicitEarlyWakeupEnd. These flags are
94 // expected to be used by WindowManager only and are guarded by
95 // android.permission.ACCESS_SURFACE_FLINGER
96 eExplicitEarlyWakeupStart = 0x08,
97 eExplicitEarlyWakeupEnd = 0x10,
Jamie Gennis28378392011-10-12 17:39:00 -070098 };
99
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700100 enum VsyncSource {
101 eVsyncSourceApp = 0,
102 eVsyncSourceSurfaceFlinger = 1
103 };
104
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700105 enum ConfigChanged { eConfigChangedSuppress = 0, eConfigChangedDispatch = 1 };
106
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800107 /*
Robert Carrb89ea9d2018-12-10 13:01:14 -0800108 * Create a connection with SurfaceFlinger.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800109 */
Mathias Agopian7e27f052010-05-28 14:22:23 -0700110 virtual sp<ISurfaceComposerClient> createConnection() = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800111
Mathias Agopiane57f2922012-08-09 16:29:12 -0700112 /* return an IDisplayEventConnection */
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700113 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700114 VsyncSource vsyncSource = eVsyncSourceApp,
115 ConfigChanged configChanged = eConfigChangedSuppress) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700116
Jesse Hall6c913be2013-08-08 12:15:49 -0700117 /* create a virtual display
Mathias Agopiane57f2922012-08-09 16:29:12 -0700118 * requires ACCESS_SURFACE_FLINGER permission.
119 */
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700120 virtual sp<IBinder> createDisplay(const String8& displayName,
121 bool secure) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700122
Jesse Hall6c913be2013-08-08 12:15:49 -0700123 /* destroy a virtual display
124 * requires ACCESS_SURFACE_FLINGER permission.
125 */
126 virtual void destroyDisplay(const sp<IBinder>& display) = 0;
127
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800128 /* get stable IDs for connected physical displays.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700129 */
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800130 virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const = 0;
131
132 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic.
133 std::optional<PhysicalDisplayId> getInternalDisplayId() const {
134 const auto displayIds = getPhysicalDisplayIds();
135 return displayIds.empty() ? std::nullopt : std::make_optional(displayIds.front());
136 }
137
138 /* get token for a physical display given its stable ID obtained via getPhysicalDisplayIds or a
139 * DisplayEventReceiver hotplug event.
140 */
141 virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const = 0;
142
143 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic.
144 sp<IBinder> getInternalDisplayToken() const {
145 const auto displayId = getInternalDisplayId();
146 return displayId ? getPhysicalDisplayToken(*displayId) : nullptr;
147 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700148
Mathias Agopian9cce3252010-02-09 17:46:37 -0800149 /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
Mathias Agopian3165cc22012-08-08 19:42:09 -0700150 virtual void setTransactionState(const Vector<ComposerState>& state,
Marissa Wall713b63f2018-10-17 15:42:43 -0700151 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -0800152 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800153 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -0700154 int64_t desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -0700155 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700156 const std::vector<ListenerCallbacks>& listenerCallbacks) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800157
158 /* signal that we're done booting.
Mathias Agopian9cce3252010-02-09 17:46:37 -0800159 * Requires ACCESS_SURFACE_FLINGER permission
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800160 */
161 virtual void bootFinished() = 0;
162
Andy McFadden2adaf042012-12-18 09:49:45 -0800163 /* verify that an IGraphicBufferProducer was created by SurfaceFlinger.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700164 */
165 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800166 const sp<IGraphicBufferProducer>& surface) const = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700167
Brian Anderson6b376712017-04-04 10:51:39 -0700168 /* Returns the frame timestamps supported by SurfaceFlinger.
169 */
170 virtual status_t getSupportedFrameTimestamps(
171 std::vector<FrameEvent>* outSupported) const = 0;
172
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700173 /* set display power mode. depending on the mode, it can either trigger
174 * screen on, off or low power mode and wait for it to complete.
Mathias Agopian041a0752013-03-15 18:31:56 -0700175 * requires ACCESS_SURFACE_FLINGER permission.
176 */
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700177 virtual void setPowerMode(const sp<IBinder>& display, int mode) = 0;
Mathias Agopian3094df32012-06-18 18:06:45 -0700178
Dan Stoza7f7da322014-05-02 15:26:25 -0700179
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700180 /* returns display statistics for a given display
181 * intended to be used by the media framework to properly schedule
182 * video frames */
183 virtual status_t getDisplayStats(const sp<IBinder>& display,
184 DisplayStatInfo* stats) = 0;
185
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800186 /**
187 * Get transactional state of given display.
188 */
189 virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState*) = 0;
190
191 /**
192 * Get immutable information about given physical display.
193 */
194 virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo*) = 0;
195
196 /**
197 * Get configurations supported by given physical display.
198 */
199 virtual status_t getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayConfig>*) = 0;
200
201 /**
202 * Get the index into configurations returned by getDisplayConfigs,
203 * corresponding to the active configuration.
204 */
Dan Stoza7f7da322014-05-02 15:26:25 -0700205 virtual int getActiveConfig(const sp<IBinder>& display) = 0;
206
Michael Wright28f24d02016-07-12 13:30:53 -0700207 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700208 Vector<ui::ColorMode>* outColorModes) = 0;
Daniel Solomon42d04562019-01-20 21:03:19 -0800209 virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display,
210 ui::DisplayPrimaries& primaries) = 0;
Peiyong Lin9f034472018-03-28 15:29:00 -0700211 virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& display) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700212 virtual status_t setActiveColorMode(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700213 ui::ColorMode colorMode) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700214
Chia-I Wuff79ef82018-08-22 15:27:32 -0700215 /**
Galia Peycheva5492cb52019-10-30 14:13:16 +0100216 * Returns true if the connected display reports support for HDMI 2.1 Auto
217 * Low Latency Mode.
218 * For more information, see the HDMI 2.1 specification.
219 */
220 virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,
221 bool* outSupport) const = 0;
222
223 /**
224 * Switches Auto Low Latency Mode on/off on the connected display, if it is
225 * available. This should only be called if #getAutoLowLatencyMode returns
226 * true.
227 * For more information, see the HDMI 2.1 specification.
228 */
229 virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) = 0;
230
231 /**
232 * Returns true if the connected display reports support for Game Content Type.
233 * For more information, see the HDMI 1.4 specification.
234 */
235 virtual status_t getGameContentTypeSupport(const sp<IBinder>& display,
236 bool* outSupport) const = 0;
237
238 /**
239 * This will start sending infoframes to the connected display with
240 * ContentType=Game (if on=true). This will switch the disply to Game mode.
241 * This should only be called if #getGameContentTypeSupport returns true.
242 * For more information, see the HDMI 1.4 specification.
243 */
244 virtual void setGameContentType(const sp<IBinder>& display, bool on) = 0;
245
246 /**
Chia-I Wuff79ef82018-08-22 15:27:32 -0700247 * Capture the specified screen. This requires READ_FRAME_BUFFER
248 * permission. This function will fail if there is a secure window on
249 * screen.
250 *
251 * This function can capture a subregion (the source crop) of the screen.
252 * The subregion can be optionally rotated. It will also be scaled to
253 * match the size of the output buffer.
254 *
Peiyong Lin0e003c92018-09-17 11:09:51 -0700255 * reqDataspace and reqPixelFormat specify the data space and pixel format
256 * of the buffer. The caller should pick the data space and pixel format
257 * that it can consume.
258 *
Yiwei Zhang11a7dbe2019-03-21 00:03:14 -0700259 * sourceCrop is the crop on the logical display.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700260 *
261 * reqWidth and reqHeight specifies the size of the buffer. When either
262 * of them is 0, they are set to the size of the logical display viewport.
263 *
264 * When useIdentityTransform is true, layer transformations are disabled.
265 *
266 * rotation specifies the rotation of the source crop (and the pixels in
267 * it) around its center.
268 */
269 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800270 bool& outCapturedSecureLayers, ui::Dataspace reqDataspace,
271 ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700272 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800273 ui::Rotation rotation = ui::ROTATION_0,
Robert Carrfa8855f2019-02-19 10:05:00 -0800274 bool captureSecureLayers = false) = 0;
Peiyong Lin0e003c92018-09-17 11:09:51 -0700275 /**
276 * Capture the specified screen. This requires READ_FRAME_BUFFER
277 * permission. This function will fail if there is a secure window on
278 * screen.
279 *
280 * This function can capture a subregion (the source crop) of the screen
281 * into an sRGB buffer with RGBA_8888 pixel format.
282 * The subregion can be optionally rotated. It will also be scaled to
283 * match the size of the output buffer.
284 *
Chia-I Wuff79ef82018-08-22 15:27:32 -0700285 * At the moment, sourceCrop is ignored and is always set to the visible
286 * region (projected display viewport) of the screen.
287 *
288 * reqWidth and reqHeight specifies the size of the buffer. When either
289 * of them is 0, they are set to the size of the logical display viewport.
290 *
291 * When useIdentityTransform is true, layer transformations are disabled.
292 *
293 * rotation specifies the rotation of the source crop (and the pixels in
294 * it) around its center.
Mathias Agopian041a0752013-03-15 18:31:56 -0700295 */
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000296 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800297 const Rect& sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
298 bool useIdentityTransform,
299 ui::Rotation rotation = ui::ROTATION_0) {
Robert Carr108b2c72019-04-02 16:32:58 -0700300 bool outIgnored;
301 return captureScreen(display, outBuffer, outIgnored, ui::Dataspace::V0_SRGB,
302 ui::PixelFormat::RGBA_8888, sourceCrop, reqWidth, reqHeight,
303 useIdentityTransform, rotation);
Peiyong Lin0e003c92018-09-17 11:09:51 -0700304 }
Svetoslavd85084b2014-03-20 10:28:31 -0700305
chaviw93df2ea2019-04-30 16:45:12 -0700306 virtual status_t captureScreen(uint64_t displayOrLayerStack, ui::Dataspace* outDataspace,
307 sp<GraphicBuffer>* outBuffer) = 0;
308
Robert Carr866455f2019-04-02 16:28:26 -0700309 template <class AA>
310 struct SpHash {
311 size_t operator()(const sp<AA>& k) const { return std::hash<AA*>()(k.get()); }
312 };
313
Robert Carr578038f2018-03-09 12:25:24 -0800314 /**
315 * Capture a subtree of the layer hierarchy, potentially ignoring the root node.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700316 *
317 * reqDataspace and reqPixelFormat specify the data space and pixel format
318 * of the buffer. The caller should pick the data space and pixel format
319 * that it can consume.
Robert Carr578038f2018-03-09 12:25:24 -0800320 */
Robert Carr866455f2019-04-02 16:28:26 -0700321 virtual status_t captureLayers(
322 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800323 ui::Dataspace reqDataspace, ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr866455f2019-04-02 16:28:26 -0700324 const std::unordered_set<sp<IBinder>, SpHash<IBinder>>& excludeHandles,
325 float frameScale = 1.0, bool childrenOnly = false) = 0;
chaviwa76b2712017-09-20 12:02:26 -0700326
Peiyong Lin0e003c92018-09-17 11:09:51 -0700327 /**
328 * Capture a subtree of the layer hierarchy into an sRGB buffer with RGBA_8888 pixel format,
329 * potentially ignoring the root node.
330 */
331 status_t captureLayers(const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
332 const Rect& sourceCrop, float frameScale = 1.0,
333 bool childrenOnly = false) {
334 return captureLayers(layerHandleBinder, outBuffer, ui::Dataspace::V0_SRGB,
Robert Carr866455f2019-04-02 16:28:26 -0700335 ui::PixelFormat::RGBA_8888, sourceCrop, {}, frameScale, childrenOnly);
Peiyong Lin0e003c92018-09-17 11:09:51 -0700336 }
337
Svetoslavd85084b2014-03-20 10:28:31 -0700338 /* Clears the frame statistics for animations.
339 *
340 * Requires the ACCESS_SURFACE_FLINGER permission.
341 */
342 virtual status_t clearAnimationFrameStats() = 0;
343
344 /* Gets the frame statistics for animations.
345 *
346 * Requires the ACCESS_SURFACE_FLINGER permission.
347 */
348 virtual status_t getAnimationFrameStats(FrameStats* outStats) const = 0;
Dan Stozac4f471e2016-03-24 09:31:08 -0700349
350 /* Gets the supported HDR capabilities of the given display.
351 *
352 * Requires the ACCESS_SURFACE_FLINGER permission.
353 */
354 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
355 HdrCapabilities* outCapabilities) const = 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700356
357 virtual status_t enableVSyncInjections(bool enable) = 0;
358
359 virtual status_t injectVSync(nsecs_t when) = 0;
Kalle Raitaa099a242017-01-11 11:17:29 -0800360
361 /* Gets the list of active layers in Z order for debugging purposes
362 *
363 * Requires the ACCESS_SURFACE_FLINGER permission.
364 */
Vishnu Nair43bccf82020-06-05 10:53:37 -0700365 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) = 0;
Peiyong Lin0256f722018-08-31 15:45:10 -0700366
Ady Abraham37965d42018-11-01 13:43:32 -0700367 virtual status_t getColorManagement(bool* outGetColorManagement) const = 0;
Peiyong Linc6780972018-10-28 15:24:08 -0700368
369 /* Gets the composition preference of the default data space and default pixel format,
370 * as well as the wide color gamut data space and wide color gamut pixel format.
371 * If the wide color gamut data space is V0_SRGB, then it implies that the platform
372 * has no wide color gamut support.
373 *
374 * Requires the ACCESS_SURFACE_FLINGER permission.
375 */
376 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
377 ui::PixelFormat* defaultPixelFormat,
378 ui::Dataspace* wideColorGamutDataspace,
379 ui::PixelFormat* wideColorGamutPixelFormat) const = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700380 /*
381 * Requires the ACCESS_SURFACE_FLINGER permission.
382 */
383 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
384 ui::PixelFormat* outFormat,
385 ui::Dataspace* outDataspace,
386 uint8_t* outComponentMask) const = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800387
388 /* Turns on the color sampling engine on the display.
389 *
390 * Requires the ACCESS_SURFACE_FLINGER permission.
391 */
392 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
393 uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700394 uint64_t maxFrames) = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700395
396 /* Returns statistics on the color profile of the last frame displayed for a given display
397 *
398 * Requires the ACCESS_SURFACE_FLINGER permission.
399 */
400 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
401 uint64_t timestamp,
402 DisplayedFrameStats* outStats) const = 0;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800403
404 /*
405 * Gets whether SurfaceFlinger can support protected content in GPU composition.
406 * Requires the ACCESS_SURFACE_FLINGER permission.
407 */
408 virtual status_t getProtectedContentSupport(bool* outSupported) const = 0;
Marissa Wallebc2c052019-01-16 19:16:55 -0800409
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800410 /*
411 * Queries whether the given display is a wide color display.
412 * Requires the ACCESS_SURFACE_FLINGER permission.
413 */
414 virtual status_t isWideColorDisplay(const sp<IBinder>& token,
415 bool* outIsWideColorDisplay) const = 0;
Dan Stoza84ab9372018-12-17 15:27:57 -0800416
417 /* Registers a listener to stream median luma updates from SurfaceFlinger.
418 *
419 * The sampling area is bounded by both samplingArea and the given stopLayerHandle
420 * (i.e., only layers behind the stop layer will be captured and sampled).
421 *
422 * Multiple listeners may be provided so long as they have independent listeners.
423 * If multiple listeners are provided, the effective sampling region for each listener will
424 * be bounded by whichever stop layer has a lower Z value.
425 *
426 * Requires the same permissions as captureLayers and captureScreen.
427 */
428 virtual status_t addRegionSamplingListener(const Rect& samplingArea,
429 const sp<IBinder>& stopLayerHandle,
430 const sp<IRegionSamplingListener>& listener) = 0;
431
432 /*
433 * Removes a listener that was streaming median luma updates from SurfaceFlinger.
434 */
435 virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) = 0;
Ady Abraham838de062019-02-04 10:24:03 -0800436
Steven Thomasf734df42020-04-13 21:09:28 -0700437 /* Sets the refresh rate boundaries for the display.
438 *
439 * The primary refresh rate range represents display manager's general guidance on the display
440 * configs we'll consider when switching refresh rates. Unless we get an explicit signal from an
441 * app, we should stay within this range.
442 *
443 * The app request refresh rate range allows us to consider more display configs when switching
444 * refresh rates. Although we should generally stay within the primary range, specific
445 * considerations, such as layer frame rate settings specified via the setFrameRate() api, may
446 * cause us to go outside the primary range. We never go outside the app request range. The app
447 * request range will be greater than or equal to the primary refresh rate range, never smaller.
448 *
449 * defaultConfig is used to narrow the list of display configs SurfaceFlinger will consider
450 * switching between. Only configs with a config group and resolution matching defaultConfig
451 * will be considered for switching. The defaultConfig index corresponds to the list of configs
452 * returned from getDisplayConfigs().
Ana Krulec0782b882019-10-15 17:34:54 -0700453 */
454 virtual status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Steven Thomasf734df42020-04-13 21:09:28 -0700455 int32_t defaultConfig,
456 float primaryRefreshRateMin,
457 float primaryRefreshRateMax,
458 float appRequestRefreshRateMin,
459 float appRequestRefreshRateMax) = 0;
Ana Krulec0782b882019-10-15 17:34:54 -0700460
Ana Krulec234bb162019-11-10 22:55:55 +0100461 virtual status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100462 int32_t* outDefaultConfig,
Steven Thomasf734df42020-04-13 21:09:28 -0700463 float* outPrimaryRefreshRateMin,
464 float* outPrimaryRefreshRateMax,
465 float* outAppRequestRefreshRateMin,
466 float* outAppRequestRefreshRateMax) = 0;
Ana Krulec0782b882019-10-15 17:34:54 -0700467 /*
Dan Gittik57e63c52019-01-18 16:37:54 +0000468 * Gets whether brightness operations are supported on a display.
469 *
470 * displayToken
471 * The token of the display.
472 * outSupport
473 * An output parameter for whether brightness operations are supported.
474 *
475 * Returns NO_ERROR upon success. Otherwise,
476 * NAME_NOT_FOUND if the display is invalid, or
477 * BAD_VALUE if the output parameter is invalid.
478 */
479 virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
480 bool* outSupport) const = 0;
481
482 /*
483 * Sets the brightness of a display.
484 *
485 * displayToken
486 * The token of the display whose brightness is set.
487 * brightness
488 * A number between 0.0f (minimum brightness) and 1.0 (maximum brightness), or -1.0f to
489 * turn the backlight off.
490 *
491 * Returns NO_ERROR upon success. Otherwise,
492 * NAME_NOT_FOUND if the display is invalid, or
493 * BAD_VALUE if the brightness is invalid, or
494 * INVALID_OPERATION if brightness operations are not supported.
495 */
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700496 virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) = 0;
Ady Abraham8532d012019-05-08 14:50:56 -0700497
498 /*
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100499 * Sends a power boost to the composer. This function is asynchronous.
Ady Abraham8532d012019-05-08 14:50:56 -0700500 *
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100501 * boostId
502 * boost id according to android::hardware::power::Boost
Ady Abraham8532d012019-05-08 14:50:56 -0700503 *
504 * Returns NO_ERROR upon success.
505 */
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100506 virtual status_t notifyPowerBoost(int32_t boostId) = 0;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800507
508 /*
509 * Sets the global configuration for all the shadows drawn by SurfaceFlinger. Shadow follows
510 * material design guidelines.
511 *
512 * ambientColor
513 * Color to the ambient shadow. The alpha is premultiplied.
514 *
515 * spotColor
516 * Color to the spot shadow. The alpha is premultiplied. The position of the spot shadow
517 * depends on the light position.
518 *
519 * lightPosY/lightPosZ
520 * Position of the light used to cast the spot shadow. The X value is always the display
521 * width / 2.
522 *
523 * lightRadius
524 * Radius of the light casting the shadow.
525 */
526 virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
527 float lightPosY, float lightPosZ,
528 float lightRadius) = 0;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800529
530 /*
531 * Sets the intended frame rate for a surface. See ANativeWindow_setFrameRate() for more info.
532 */
533 virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
534 int8_t compatibility) = 0;
Steven Thomasd4071902020-03-24 16:02:53 -0700535
536 /*
537 * Acquire a frame rate flexibility token from SurfaceFlinger. While this token is acquired,
538 * surface flinger will freely switch between frame rates in any way it sees fit, regardless of
539 * the current restrictions applied by DisplayManager. This is useful to get consistent behavior
540 * for tests. Release the token by releasing the returned IBinder reference.
541 */
542 virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800543};
544
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800545// ----------------------------------------------------------------------------
546
Mathias Agopian3165cc22012-08-08 19:42:09 -0700547class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800548public:
Ana Krulec13be8ad2018-08-21 02:43:56 +0000549 enum ISurfaceComposerTag {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800550 // Note: BOOT_FINISHED must remain this value, it is called from
551 // Java by ActivityManagerService.
552 BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,
553 CREATE_CONNECTION,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800554 GET_DISPLAY_INFO,
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800555 CREATE_DISPLAY_EVENT_CONNECTION,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700556 CREATE_DISPLAY,
Jesse Hall6c913be2013-08-08 12:15:49 -0700557 DESTROY_DISPLAY,
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800558 GET_PHYSICAL_DISPLAY_TOKEN,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700559 SET_TRANSACTION_STATE,
560 AUTHENTICATE_SURFACE,
Brian Anderson069b3652016-07-22 10:32:47 -0700561 GET_SUPPORTED_FRAME_TIMESTAMPS,
Dan Stoza7f7da322014-05-02 15:26:25 -0700562 GET_DISPLAY_CONFIGS,
563 GET_ACTIVE_CONFIG,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800564 GET_DISPLAY_STATE,
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800565 CAPTURE_SCREEN,
chaviwa76b2712017-09-20 12:02:26 -0700566 CAPTURE_LAYERS,
Svetoslavd85084b2014-03-20 10:28:31 -0700567 CLEAR_ANIMATION_FRAME_STATS,
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700568 GET_ANIMATION_FRAME_STATS,
569 SET_POWER_MODE,
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700570 GET_DISPLAY_STATS,
Dan Stozac4f471e2016-03-24 09:31:08 -0700571 GET_HDR_CAPABILITIES,
Michael Wright28f24d02016-07-12 13:30:53 -0700572 GET_DISPLAY_COLOR_MODES,
573 GET_ACTIVE_COLOR_MODE,
574 SET_ACTIVE_COLOR_MODE,
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700575 ENABLE_VSYNC_INJECTIONS,
Robert Carr1db73f62016-12-21 12:58:51 -0800576 INJECT_VSYNC,
Kalle Raitaa099a242017-01-11 11:17:29 -0800577 GET_LAYER_DEBUG_INFO,
Peiyong Lin0256f722018-08-31 15:45:10 -0700578 GET_COMPOSITION_PREFERENCE,
Ady Abraham37965d42018-11-01 13:43:32 -0700579 GET_COLOR_MANAGEMENT,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700580 GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES,
Kevin DuBois74e53772018-11-19 10:52:38 -0800581 SET_DISPLAY_CONTENT_SAMPLING_ENABLED,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700582 GET_DISPLAYED_CONTENT_SAMPLE,
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800583 GET_PROTECTED_CONTENT_SUPPORT,
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800584 IS_WIDE_COLOR_DISPLAY,
Daniel Solomon42d04562019-01-20 21:03:19 -0800585 GET_DISPLAY_NATIVE_PRIMARIES,
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800586 GET_PHYSICAL_DISPLAY_IDS,
Dan Stoza84ab9372018-12-17 15:27:57 -0800587 ADD_REGION_SAMPLING_LISTENER,
588 REMOVE_REGION_SAMPLING_LISTENER,
Ana Krulec0782b882019-10-15 17:34:54 -0700589 SET_DESIRED_DISPLAY_CONFIG_SPECS,
Ana Krulec234bb162019-11-10 22:55:55 +0100590 GET_DESIRED_DISPLAY_CONFIG_SPECS,
Dan Gittik57e63c52019-01-18 16:37:54 +0000591 GET_DISPLAY_BRIGHTNESS_SUPPORT,
592 SET_DISPLAY_BRIGHTNESS,
chaviw93df2ea2019-04-30 16:45:12 -0700593 CAPTURE_SCREEN_BY_ID,
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100594 NOTIFY_POWER_BOOST,
Vishnu Nairb13bb952019-11-15 10:24:08 -0800595 SET_GLOBAL_SHADOW_SETTINGS,
Galia Peycheva5492cb52019-10-30 14:13:16 +0100596 GET_AUTO_LOW_LATENCY_MODE_SUPPORT,
597 SET_AUTO_LOW_LATENCY_MODE,
598 GET_GAME_CONTENT_TYPE_SUPPORT,
599 SET_GAME_CONTENT_TYPE,
Steven Thomas62a4cf82020-01-31 12:04:03 -0800600 SET_FRAME_RATE,
Steven Thomasd4071902020-03-24 16:02:53 -0700601 ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN,
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800602 // Always append new enum to the end.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800603 };
604
Mathias Agopian3165cc22012-08-08 19:42:09 -0700605 virtual status_t onTransact(uint32_t code, const Parcel& data,
606 Parcel* reply, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800607};
608
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800609} // namespace android