blob: e2042859351961ac119802e52c0dab7f0362e946 [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>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070030#include <ui/DisplayedFrameStats.h>
Svetoslavd85084b2014-03-20 10:28:31 -070031#include <ui/FrameStats.h>
Chavi Weingarten40482ff2017-11-30 01:51:40 +000032#include <ui/GraphicBuffer.h>
Peiyong Lin9f034472018-03-28 15:29:00 -070033#include <ui/GraphicTypes.h>
Dominik Laskowski5acb2b82019-11-01 13:16:38 -070034#include <ui/PhysicalDisplayId.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,
Jamie Gennis2d5e2302012-10-15 18:24:43 -070084 eAnimation = 0x02,
Dan Stoza84d619e2018-03-28 17:07:36 -070085
86 // Indicates that this transaction will likely result in a lot of layers being composed, and
87 // thus, SurfaceFlinger should wake-up earlier to avoid missing frame deadlines. In this
88 // case SurfaceFlinger will wake up at (sf vsync offset - debug.sf.early_phase_offset_ns)
89 eEarlyWakeup = 0x04
Jamie Gennis28378392011-10-12 17:39:00 -070090 };
91
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -070092 enum VsyncSource {
93 eVsyncSourceApp = 0,
94 eVsyncSourceSurfaceFlinger = 1
95 };
96
Ady Abraham0f4a1b12019-06-04 16:04:04 -070097 enum ConfigChanged { eConfigChangedSuppress = 0, eConfigChangedDispatch = 1 };
98
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -080099 /*
Robert Carrb89ea9d2018-12-10 13:01:14 -0800100 * Create a connection with SurfaceFlinger.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800101 */
Mathias Agopian7e27f052010-05-28 14:22:23 -0700102 virtual sp<ISurfaceComposerClient> createConnection() = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800103
Mathias Agopiane57f2922012-08-09 16:29:12 -0700104 /* return an IDisplayEventConnection */
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -0700105 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
Ady Abraham0f4a1b12019-06-04 16:04:04 -0700106 VsyncSource vsyncSource = eVsyncSourceApp,
107 ConfigChanged configChanged = eConfigChangedSuppress) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700108
Jesse Hall6c913be2013-08-08 12:15:49 -0700109 /* create a virtual display
Mathias Agopiane57f2922012-08-09 16:29:12 -0700110 * requires ACCESS_SURFACE_FLINGER permission.
111 */
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700112 virtual sp<IBinder> createDisplay(const String8& displayName,
113 bool secure) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700114
Jesse Hall6c913be2013-08-08 12:15:49 -0700115 /* destroy a virtual display
116 * requires ACCESS_SURFACE_FLINGER permission.
117 */
118 virtual void destroyDisplay(const sp<IBinder>& display) = 0;
119
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800120 /* get stable IDs for connected physical displays.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700121 */
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800122 virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const = 0;
123
124 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic.
125 std::optional<PhysicalDisplayId> getInternalDisplayId() const {
126 const auto displayIds = getPhysicalDisplayIds();
127 return displayIds.empty() ? std::nullopt : std::make_optional(displayIds.front());
128 }
129
130 /* get token for a physical display given its stable ID obtained via getPhysicalDisplayIds or a
131 * DisplayEventReceiver hotplug event.
132 */
133 virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const = 0;
134
135 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic.
136 sp<IBinder> getInternalDisplayToken() const {
137 const auto displayId = getInternalDisplayId();
138 return displayId ? getPhysicalDisplayToken(*displayId) : nullptr;
139 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700140
Mathias Agopian9cce3252010-02-09 17:46:37 -0800141 /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
Mathias Agopian3165cc22012-08-08 19:42:09 -0700142 virtual void setTransactionState(const Vector<ComposerState>& state,
Marissa Wall713b63f2018-10-17 15:42:43 -0700143 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -0800144 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800145 const InputWindowCommands& inputWindowCommands,
Marissa Wall78b72202019-03-15 14:58:34 -0700146 int64_t desiredPresentTime,
Valerie Hau9dab9732019-08-20 09:29:25 -0700147 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Marissa Wall3dad52d2019-03-22 14:03:19 -0700148 const std::vector<ListenerCallbacks>& listenerCallbacks) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800149
150 /* signal that we're done booting.
Mathias Agopian9cce3252010-02-09 17:46:37 -0800151 * Requires ACCESS_SURFACE_FLINGER permission
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800152 */
153 virtual void bootFinished() = 0;
154
Andy McFadden2adaf042012-12-18 09:49:45 -0800155 /* verify that an IGraphicBufferProducer was created by SurfaceFlinger.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700156 */
157 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800158 const sp<IGraphicBufferProducer>& surface) const = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700159
Brian Anderson6b376712017-04-04 10:51:39 -0700160 /* Returns the frame timestamps supported by SurfaceFlinger.
161 */
162 virtual status_t getSupportedFrameTimestamps(
163 std::vector<FrameEvent>* outSupported) const = 0;
164
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700165 /* set display power mode. depending on the mode, it can either trigger
166 * screen on, off or low power mode and wait for it to complete.
Mathias Agopian041a0752013-03-15 18:31:56 -0700167 * requires ACCESS_SURFACE_FLINGER permission.
168 */
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700169 virtual void setPowerMode(const sp<IBinder>& display, int mode) = 0;
Mathias Agopian3094df32012-06-18 18:06:45 -0700170
Dan Stoza7f7da322014-05-02 15:26:25 -0700171
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700172 /* returns display statistics for a given display
173 * intended to be used by the media framework to properly schedule
174 * video frames */
175 virtual status_t getDisplayStats(const sp<IBinder>& display,
176 DisplayStatInfo* stats) = 0;
177
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800178 /**
179 * Get transactional state of given display.
180 */
181 virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState*) = 0;
182
183 /**
184 * Get immutable information about given physical display.
185 */
186 virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo*) = 0;
187
188 /**
189 * Get configurations supported by given physical display.
190 */
191 virtual status_t getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayConfig>*) = 0;
192
193 /**
194 * Get the index into configurations returned by getDisplayConfigs,
195 * corresponding to the active configuration.
196 */
Dan Stoza7f7da322014-05-02 15:26:25 -0700197 virtual int getActiveConfig(const sp<IBinder>& display) = 0;
198
Michael Wright28f24d02016-07-12 13:30:53 -0700199 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700200 Vector<ui::ColorMode>* outColorModes) = 0;
Daniel Solomon42d04562019-01-20 21:03:19 -0800201 virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display,
202 ui::DisplayPrimaries& primaries) = 0;
Peiyong Lin9f034472018-03-28 15:29:00 -0700203 virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& display) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700204 virtual status_t setActiveColorMode(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700205 ui::ColorMode colorMode) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700206
Chia-I Wuff79ef82018-08-22 15:27:32 -0700207 /**
Galia Peycheva5492cb52019-10-30 14:13:16 +0100208 * Returns true if the connected display reports support for HDMI 2.1 Auto
209 * Low Latency Mode.
210 * For more information, see the HDMI 2.1 specification.
211 */
212 virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,
213 bool* outSupport) const = 0;
214
215 /**
216 * Switches Auto Low Latency Mode on/off on the connected display, if it is
217 * available. This should only be called if #getAutoLowLatencyMode returns
218 * true.
219 * For more information, see the HDMI 2.1 specification.
220 */
221 virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) = 0;
222
223 /**
224 * Returns true if the connected display reports support for Game Content Type.
225 * For more information, see the HDMI 1.4 specification.
226 */
227 virtual status_t getGameContentTypeSupport(const sp<IBinder>& display,
228 bool* outSupport) const = 0;
229
230 /**
231 * This will start sending infoframes to the connected display with
232 * ContentType=Game (if on=true). This will switch the disply to Game mode.
233 * This should only be called if #getGameContentTypeSupport returns true.
234 * For more information, see the HDMI 1.4 specification.
235 */
236 virtual void setGameContentType(const sp<IBinder>& display, bool on) = 0;
237
238 /**
Chia-I Wuff79ef82018-08-22 15:27:32 -0700239 * Capture the specified screen. This requires READ_FRAME_BUFFER
240 * permission. This function will fail if there is a secure window on
241 * screen.
242 *
243 * This function can capture a subregion (the source crop) of the screen.
244 * The subregion can be optionally rotated. It will also be scaled to
245 * match the size of the output buffer.
246 *
Peiyong Lin0e003c92018-09-17 11:09:51 -0700247 * reqDataspace and reqPixelFormat specify the data space and pixel format
248 * of the buffer. The caller should pick the data space and pixel format
249 * that it can consume.
250 *
Yiwei Zhang11a7dbe2019-03-21 00:03:14 -0700251 * sourceCrop is the crop on the logical display.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700252 *
253 * reqWidth and reqHeight specifies the size of the buffer. When either
254 * of them is 0, they are set to the size of the logical display viewport.
255 *
256 * When useIdentityTransform is true, layer transformations are disabled.
257 *
258 * rotation specifies the rotation of the source crop (and the pixels in
259 * it) around its center.
260 */
261 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800262 bool& outCapturedSecureLayers, ui::Dataspace reqDataspace,
263 ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700264 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800265 ui::Rotation rotation = ui::ROTATION_0,
Robert Carrfa8855f2019-02-19 10:05:00 -0800266 bool captureSecureLayers = false) = 0;
Peiyong Lin0e003c92018-09-17 11:09:51 -0700267 /**
268 * Capture the specified screen. This requires READ_FRAME_BUFFER
269 * permission. This function will fail if there is a secure window on
270 * screen.
271 *
272 * This function can capture a subregion (the source crop) of the screen
273 * into an sRGB buffer with RGBA_8888 pixel format.
274 * The subregion can be optionally rotated. It will also be scaled to
275 * match the size of the output buffer.
276 *
Chia-I Wuff79ef82018-08-22 15:27:32 -0700277 * At the moment, sourceCrop is ignored and is always set to the visible
278 * region (projected display viewport) of the screen.
279 *
280 * reqWidth and reqHeight specifies the size of the buffer. When either
281 * of them is 0, they are set to the size of the logical display viewport.
282 *
283 * When useIdentityTransform is true, layer transformations are disabled.
284 *
285 * rotation specifies the rotation of the source crop (and the pixels in
286 * it) around its center.
Mathias Agopian041a0752013-03-15 18:31:56 -0700287 */
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000288 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800289 const Rect& sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
290 bool useIdentityTransform,
291 ui::Rotation rotation = ui::ROTATION_0) {
Robert Carr108b2c72019-04-02 16:32:58 -0700292 bool outIgnored;
293 return captureScreen(display, outBuffer, outIgnored, ui::Dataspace::V0_SRGB,
294 ui::PixelFormat::RGBA_8888, sourceCrop, reqWidth, reqHeight,
295 useIdentityTransform, rotation);
Peiyong Lin0e003c92018-09-17 11:09:51 -0700296 }
Svetoslavd85084b2014-03-20 10:28:31 -0700297
chaviw93df2ea2019-04-30 16:45:12 -0700298 virtual status_t captureScreen(uint64_t displayOrLayerStack, ui::Dataspace* outDataspace,
299 sp<GraphicBuffer>* outBuffer) = 0;
300
Robert Carr866455f2019-04-02 16:28:26 -0700301 template <class AA>
302 struct SpHash {
303 size_t operator()(const sp<AA>& k) const { return std::hash<AA*>()(k.get()); }
304 };
305
Robert Carr578038f2018-03-09 12:25:24 -0800306 /**
307 * Capture a subtree of the layer hierarchy, potentially ignoring the root node.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700308 *
309 * reqDataspace and reqPixelFormat specify the data space and pixel format
310 * of the buffer. The caller should pick the data space and pixel format
311 * that it can consume.
Robert Carr578038f2018-03-09 12:25:24 -0800312 */
Robert Carr866455f2019-04-02 16:28:26 -0700313 virtual status_t captureLayers(
314 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
Dominik Laskowski718f9602019-11-09 20:01:35 -0800315 ui::Dataspace reqDataspace, ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr866455f2019-04-02 16:28:26 -0700316 const std::unordered_set<sp<IBinder>, SpHash<IBinder>>& excludeHandles,
317 float frameScale = 1.0, bool childrenOnly = false) = 0;
chaviwa76b2712017-09-20 12:02:26 -0700318
Peiyong Lin0e003c92018-09-17 11:09:51 -0700319 /**
320 * Capture a subtree of the layer hierarchy into an sRGB buffer with RGBA_8888 pixel format,
321 * potentially ignoring the root node.
322 */
323 status_t captureLayers(const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
324 const Rect& sourceCrop, float frameScale = 1.0,
325 bool childrenOnly = false) {
326 return captureLayers(layerHandleBinder, outBuffer, ui::Dataspace::V0_SRGB,
Robert Carr866455f2019-04-02 16:28:26 -0700327 ui::PixelFormat::RGBA_8888, sourceCrop, {}, frameScale, childrenOnly);
Peiyong Lin0e003c92018-09-17 11:09:51 -0700328 }
329
Svetoslavd85084b2014-03-20 10:28:31 -0700330 /* Clears the frame statistics for animations.
331 *
332 * Requires the ACCESS_SURFACE_FLINGER permission.
333 */
334 virtual status_t clearAnimationFrameStats() = 0;
335
336 /* Gets the frame statistics for animations.
337 *
338 * Requires the ACCESS_SURFACE_FLINGER permission.
339 */
340 virtual status_t getAnimationFrameStats(FrameStats* outStats) const = 0;
Dan Stozac4f471e2016-03-24 09:31:08 -0700341
342 /* Gets the supported HDR capabilities of the given display.
343 *
344 * Requires the ACCESS_SURFACE_FLINGER permission.
345 */
346 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
347 HdrCapabilities* outCapabilities) const = 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700348
349 virtual status_t enableVSyncInjections(bool enable) = 0;
350
351 virtual status_t injectVSync(nsecs_t when) = 0;
Kalle Raitaa099a242017-01-11 11:17:29 -0800352
353 /* Gets the list of active layers in Z order for debugging purposes
354 *
355 * Requires the ACCESS_SURFACE_FLINGER permission.
356 */
357 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const = 0;
Peiyong Lin0256f722018-08-31 15:45:10 -0700358
Ady Abraham37965d42018-11-01 13:43:32 -0700359 virtual status_t getColorManagement(bool* outGetColorManagement) const = 0;
Peiyong Linc6780972018-10-28 15:24:08 -0700360
361 /* Gets the composition preference of the default data space and default pixel format,
362 * as well as the wide color gamut data space and wide color gamut pixel format.
363 * If the wide color gamut data space is V0_SRGB, then it implies that the platform
364 * has no wide color gamut support.
365 *
366 * Requires the ACCESS_SURFACE_FLINGER permission.
367 */
368 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
369 ui::PixelFormat* defaultPixelFormat,
370 ui::Dataspace* wideColorGamutDataspace,
371 ui::PixelFormat* wideColorGamutPixelFormat) const = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700372 /*
373 * Requires the ACCESS_SURFACE_FLINGER permission.
374 */
375 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
376 ui::PixelFormat* outFormat,
377 ui::Dataspace* outDataspace,
378 uint8_t* outComponentMask) const = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800379
380 /* Turns on the color sampling engine on the display.
381 *
382 * Requires the ACCESS_SURFACE_FLINGER permission.
383 */
384 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
385 uint8_t componentMask,
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700386 uint64_t maxFrames) = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700387
388 /* Returns statistics on the color profile of the last frame displayed for a given display
389 *
390 * Requires the ACCESS_SURFACE_FLINGER permission.
391 */
392 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
393 uint64_t timestamp,
394 DisplayedFrameStats* outStats) const = 0;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800395
396 /*
397 * Gets whether SurfaceFlinger can support protected content in GPU composition.
398 * Requires the ACCESS_SURFACE_FLINGER permission.
399 */
400 virtual status_t getProtectedContentSupport(bool* outSupported) const = 0;
Marissa Wallebc2c052019-01-16 19:16:55 -0800401
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800402 /*
403 * Queries whether the given display is a wide color display.
404 * Requires the ACCESS_SURFACE_FLINGER permission.
405 */
406 virtual status_t isWideColorDisplay(const sp<IBinder>& token,
407 bool* outIsWideColorDisplay) const = 0;
Dan Stoza84ab9372018-12-17 15:27:57 -0800408
409 /* Registers a listener to stream median luma updates from SurfaceFlinger.
410 *
411 * The sampling area is bounded by both samplingArea and the given stopLayerHandle
412 * (i.e., only layers behind the stop layer will be captured and sampled).
413 *
414 * Multiple listeners may be provided so long as they have independent listeners.
415 * If multiple listeners are provided, the effective sampling region for each listener will
416 * be bounded by whichever stop layer has a lower Z value.
417 *
418 * Requires the same permissions as captureLayers and captureScreen.
419 */
420 virtual status_t addRegionSamplingListener(const Rect& samplingArea,
421 const sp<IBinder>& stopLayerHandle,
422 const sp<IRegionSamplingListener>& listener) = 0;
423
424 /*
425 * Removes a listener that was streaming median luma updates from SurfaceFlinger.
426 */
427 virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) = 0;
Ady Abraham838de062019-02-04 10:24:03 -0800428
429 /*
Ana Krulec0782b882019-10-15 17:34:54 -0700430 * Sets the refresh rate boundaries for display configuration.
431 * For all other parameters, default configuration is used. The index for the default is
432 * corresponding to the configs returned from getDisplayConfigs().
433 */
434 virtual status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100435 int32_t defaultConfig, float minRefreshRate,
Ana Krulec0782b882019-10-15 17:34:54 -0700436 float maxRefreshRate) = 0;
437
Ana Krulec234bb162019-11-10 22:55:55 +0100438 virtual status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100439 int32_t* outDefaultConfig,
Ana Krulec234bb162019-11-10 22:55:55 +0100440 float* outMinRefreshRate,
441 float* outMaxRefreshRate) = 0;
Ana Krulec0782b882019-10-15 17:34:54 -0700442 /*
Dan Gittik57e63c52019-01-18 16:37:54 +0000443 * Gets whether brightness operations are supported on a display.
444 *
445 * displayToken
446 * The token of the display.
447 * outSupport
448 * An output parameter for whether brightness operations are supported.
449 *
450 * Returns NO_ERROR upon success. Otherwise,
451 * NAME_NOT_FOUND if the display is invalid, or
452 * BAD_VALUE if the output parameter is invalid.
453 */
454 virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
455 bool* outSupport) const = 0;
456
457 /*
458 * Sets the brightness of a display.
459 *
460 * displayToken
461 * The token of the display whose brightness is set.
462 * brightness
463 * A number between 0.0f (minimum brightness) and 1.0 (maximum brightness), or -1.0f to
464 * turn the backlight off.
465 *
466 * Returns NO_ERROR upon success. Otherwise,
467 * NAME_NOT_FOUND if the display is invalid, or
468 * BAD_VALUE if the brightness is invalid, or
469 * INVALID_OPERATION if brightness operations are not supported.
470 */
Dominik Laskowski470df5f2020-04-02 22:27:42 -0700471 virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) = 0;
Ady Abraham8532d012019-05-08 14:50:56 -0700472
473 /*
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100474 * Sends a power boost to the composer. This function is asynchronous.
Ady Abraham8532d012019-05-08 14:50:56 -0700475 *
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100476 * boostId
477 * boost id according to android::hardware::power::Boost
Ady Abraham8532d012019-05-08 14:50:56 -0700478 *
479 * Returns NO_ERROR upon success.
480 */
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100481 virtual status_t notifyPowerBoost(int32_t boostId) = 0;
Vishnu Nairb13bb952019-11-15 10:24:08 -0800482
483 /*
484 * Sets the global configuration for all the shadows drawn by SurfaceFlinger. Shadow follows
485 * material design guidelines.
486 *
487 * ambientColor
488 * Color to the ambient shadow. The alpha is premultiplied.
489 *
490 * spotColor
491 * Color to the spot shadow. The alpha is premultiplied. The position of the spot shadow
492 * depends on the light position.
493 *
494 * lightPosY/lightPosZ
495 * Position of the light used to cast the spot shadow. The X value is always the display
496 * width / 2.
497 *
498 * lightRadius
499 * Radius of the light casting the shadow.
500 */
501 virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
502 float lightPosY, float lightPosZ,
503 float lightRadius) = 0;
Steven Thomas62a4cf82020-01-31 12:04:03 -0800504
505 /*
506 * Sets the intended frame rate for a surface. See ANativeWindow_setFrameRate() for more info.
507 */
508 virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
509 int8_t compatibility) = 0;
Steven Thomasd4071902020-03-24 16:02:53 -0700510
511 /*
512 * Acquire a frame rate flexibility token from SurfaceFlinger. While this token is acquired,
513 * surface flinger will freely switch between frame rates in any way it sees fit, regardless of
514 * the current restrictions applied by DisplayManager. This is useful to get consistent behavior
515 * for tests. Release the token by releasing the returned IBinder reference.
516 */
517 virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800518};
519
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800520// ----------------------------------------------------------------------------
521
Mathias Agopian3165cc22012-08-08 19:42:09 -0700522class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800523public:
Ana Krulec13be8ad2018-08-21 02:43:56 +0000524 enum ISurfaceComposerTag {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800525 // Note: BOOT_FINISHED must remain this value, it is called from
526 // Java by ActivityManagerService.
527 BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,
528 CREATE_CONNECTION,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800529 GET_DISPLAY_INFO,
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800530 CREATE_DISPLAY_EVENT_CONNECTION,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700531 CREATE_DISPLAY,
Jesse Hall6c913be2013-08-08 12:15:49 -0700532 DESTROY_DISPLAY,
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800533 GET_PHYSICAL_DISPLAY_TOKEN,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700534 SET_TRANSACTION_STATE,
535 AUTHENTICATE_SURFACE,
Brian Anderson069b3652016-07-22 10:32:47 -0700536 GET_SUPPORTED_FRAME_TIMESTAMPS,
Dan Stoza7f7da322014-05-02 15:26:25 -0700537 GET_DISPLAY_CONFIGS,
538 GET_ACTIVE_CONFIG,
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800539 GET_DISPLAY_STATE,
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800540 CAPTURE_SCREEN,
chaviwa76b2712017-09-20 12:02:26 -0700541 CAPTURE_LAYERS,
Svetoslavd85084b2014-03-20 10:28:31 -0700542 CLEAR_ANIMATION_FRAME_STATS,
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700543 GET_ANIMATION_FRAME_STATS,
544 SET_POWER_MODE,
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700545 GET_DISPLAY_STATS,
Dan Stozac4f471e2016-03-24 09:31:08 -0700546 GET_HDR_CAPABILITIES,
Michael Wright28f24d02016-07-12 13:30:53 -0700547 GET_DISPLAY_COLOR_MODES,
548 GET_ACTIVE_COLOR_MODE,
549 SET_ACTIVE_COLOR_MODE,
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700550 ENABLE_VSYNC_INJECTIONS,
Robert Carr1db73f62016-12-21 12:58:51 -0800551 INJECT_VSYNC,
Kalle Raitaa099a242017-01-11 11:17:29 -0800552 GET_LAYER_DEBUG_INFO,
Peiyong Lin0256f722018-08-31 15:45:10 -0700553 GET_COMPOSITION_PREFERENCE,
Ady Abraham37965d42018-11-01 13:43:32 -0700554 GET_COLOR_MANAGEMENT,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700555 GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES,
Kevin DuBois74e53772018-11-19 10:52:38 -0800556 SET_DISPLAY_CONTENT_SAMPLING_ENABLED,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700557 GET_DISPLAYED_CONTENT_SAMPLE,
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800558 GET_PROTECTED_CONTENT_SUPPORT,
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800559 IS_WIDE_COLOR_DISPLAY,
Daniel Solomon42d04562019-01-20 21:03:19 -0800560 GET_DISPLAY_NATIVE_PRIMARIES,
Dominik Laskowskidcb38bb2019-01-25 02:35:50 -0800561 GET_PHYSICAL_DISPLAY_IDS,
Dan Stoza84ab9372018-12-17 15:27:57 -0800562 ADD_REGION_SAMPLING_LISTENER,
563 REMOVE_REGION_SAMPLING_LISTENER,
Ana Krulec0782b882019-10-15 17:34:54 -0700564 SET_DESIRED_DISPLAY_CONFIG_SPECS,
Ana Krulec234bb162019-11-10 22:55:55 +0100565 GET_DESIRED_DISPLAY_CONFIG_SPECS,
Dan Gittik57e63c52019-01-18 16:37:54 +0000566 GET_DISPLAY_BRIGHTNESS_SUPPORT,
567 SET_DISPLAY_BRIGHTNESS,
chaviw93df2ea2019-04-30 16:45:12 -0700568 CAPTURE_SCREEN_BY_ID,
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100569 NOTIFY_POWER_BOOST,
Vishnu Nairb13bb952019-11-15 10:24:08 -0800570 SET_GLOBAL_SHADOW_SETTINGS,
Galia Peycheva5492cb52019-10-30 14:13:16 +0100571 GET_AUTO_LOW_LATENCY_MODE_SUPPORT,
572 SET_AUTO_LOW_LATENCY_MODE,
573 GET_GAME_CONTENT_TYPE_SUPPORT,
574 SET_GAME_CONTENT_TYPE,
Steven Thomas62a4cf82020-01-31 12:04:03 -0800575 SET_FRAME_RATE,
Steven Thomasd4071902020-03-24 16:02:53 -0700576 ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN,
Peiyong Lin4f3fddf2019-01-24 17:21:24 -0800577 // Always append new enum to the end.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800578 };
579
Mathias Agopian3165cc22012-08-08 19:42:09 -0700580 virtual status_t onTransact(uint32_t code, const Parcel& data,
581 Parcel* reply, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800582};
583
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800584} // namespace android