blob: 418d5fbf350ad64e757ad8ee76596085dbc001e1 [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
Mathias Agopian90ac7992012-02-25 18:48:35 -080017#ifndef ANDROID_GUI_ISURFACE_COMPOSER_H
18#define ANDROID_GUI_ISURFACE_COMPOSER_H
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080019
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <utils/RefBase.h>
24#include <utils/Errors.h>
Svetoslavd85084b2014-03-20 10:28:31 -070025#include <utils/Timers.h>
26#include <utils/Vector.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080027
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070028#include <binder/IInterface.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080029
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>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070034#include <ui/PixelFormat.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035
Brian Anderson069b3652016-07-22 10:32:47 -070036#include <vector>
37
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080038namespace android {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080039// ----------------------------------------------------------------------------
40
Colin Crossa2362b42016-09-26 13:48:25 -070041struct ComposerState;
42struct DisplayState;
Jesse Hall646f5412014-08-07 22:19:07 -070043struct DisplayInfo;
Lajos Molnare7bda062014-09-18 20:05:27 -070044struct DisplayStatInfo;
chaviw273171b2018-12-26 11:46:30 -080045struct InputWindowCommands;
Kalle Raitaa099a242017-01-11 11:17:29 -080046class LayerDebugInfo;
Dan Stozac4f471e2016-03-24 09:31:08 -070047class HdrCapabilities;
Mathias Agopiand0566bc2011-11-17 17:49:17 -080048class IDisplayEventConnection;
Mathias Agopian2b5dd402017-02-07 17:36:19 -080049class IGraphicBufferProducer;
50class ISurfaceComposerClient;
Dan Stozac1879002014-05-22 15:59:05 -070051class Rect;
Brian Anderson3890c392016-07-25 12:48:08 -070052enum class FrameEvent;
Mathias Agopiana67932f2011-04-20 14:20:59 -070053
Andy McFadden882e3a32013-01-08 16:06:15 -080054/*
55 * This class defines the Binder IPC interface for accessing various
56 * SurfaceFlinger features.
57 */
Mathias Agopian3165cc22012-08-08 19:42:09 -070058class ISurfaceComposer: public IInterface {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080059public:
Colin Cross17576de2016-09-26 13:07:06 -070060 DECLARE_META_INTERFACE(SurfaceComposer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080061
Mathias Agopian3165cc22012-08-08 19:42:09 -070062 // flags for setTransactionState()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080063 enum {
Mathias Agopian3165cc22012-08-08 19:42:09 -070064 eSynchronous = 0x01,
Jamie Gennis2d5e2302012-10-15 18:24:43 -070065 eAnimation = 0x02,
Dan Stoza84d619e2018-03-28 17:07:36 -070066
67 // Indicates that this transaction will likely result in a lot of layers being composed, and
68 // thus, SurfaceFlinger should wake-up earlier to avoid missing frame deadlines. In this
69 // case SurfaceFlinger will wake up at (sf vsync offset - debug.sf.early_phase_offset_ns)
70 eEarlyWakeup = 0x04
Jamie Gennis28378392011-10-12 17:39:00 -070071 };
72
Mathias Agopiane57f2922012-08-09 16:29:12 -070073 enum {
74 eDisplayIdMain = 0,
75 eDisplayIdHdmi = 1
76 };
77
Riley Andrewsc3ebe662014-09-04 16:20:31 -070078 enum Rotation {
79 eRotateNone = 0,
80 eRotate90 = 1,
81 eRotate180 = 2,
82 eRotate270 = 3
83 };
84
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -070085 enum VsyncSource {
86 eVsyncSourceApp = 0,
87 eVsyncSourceSurfaceFlinger = 1
88 };
89
Robert Carrb89ea9d2018-12-10 13:01:14 -080090 /*
91 * Create a connection with SurfaceFlinger.
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080092 */
Mathias Agopian7e27f052010-05-28 14:22:23 -070093 virtual sp<ISurfaceComposerClient> createConnection() = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080094
Mathias Agopiane57f2922012-08-09 16:29:12 -070095 /* return an IDisplayEventConnection */
Jorim Jaggib1e2f8d2017-06-08 15:43:59 -070096 virtual sp<IDisplayEventConnection> createDisplayEventConnection(
97 VsyncSource vsyncSource = eVsyncSourceApp) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -070098
Jesse Hall6c913be2013-08-08 12:15:49 -070099 /* create a virtual display
Mathias Agopiane57f2922012-08-09 16:29:12 -0700100 * requires ACCESS_SURFACE_FLINGER permission.
101 */
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700102 virtual sp<IBinder> createDisplay(const String8& displayName,
103 bool secure) = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700104
Jesse Hall6c913be2013-08-08 12:15:49 -0700105 /* destroy a virtual display
106 * requires ACCESS_SURFACE_FLINGER permission.
107 */
108 virtual void destroyDisplay(const sp<IBinder>& display) = 0;
109
Mathias Agopiane57f2922012-08-09 16:29:12 -0700110 /* get the token for the existing default displays. possible values
111 * for id are eDisplayIdMain and eDisplayIdHdmi.
112 */
113 virtual sp<IBinder> getBuiltInDisplay(int32_t id) = 0;
114
Mathias Agopian9cce3252010-02-09 17:46:37 -0800115 /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
Mathias Agopian3165cc22012-08-08 19:42:09 -0700116 virtual void setTransactionState(const Vector<ComposerState>& state,
Marissa Wall713b63f2018-10-17 15:42:43 -0700117 const Vector<DisplayState>& displays, uint32_t flags,
chaviw273171b2018-12-26 11:46:30 -0800118 const sp<IBinder>& applyToken,
Marissa Wall17b4e452018-12-26 16:32:34 -0800119 const InputWindowCommands& inputWindowCommands,
120 int64_t desiredPresentTime) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800121
122 /* signal that we're done booting.
Mathias Agopian9cce3252010-02-09 17:46:37 -0800123 * Requires ACCESS_SURFACE_FLINGER permission
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800124 */
125 virtual void bootFinished() = 0;
126
Andy McFadden2adaf042012-12-18 09:49:45 -0800127 /* verify that an IGraphicBufferProducer was created by SurfaceFlinger.
Mathias Agopiane57f2922012-08-09 16:29:12 -0700128 */
129 virtual bool authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800130 const sp<IGraphicBufferProducer>& surface) const = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700131
Brian Anderson6b376712017-04-04 10:51:39 -0700132 /* Returns the frame timestamps supported by SurfaceFlinger.
133 */
134 virtual status_t getSupportedFrameTimestamps(
135 std::vector<FrameEvent>* outSupported) const = 0;
136
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700137 /* set display power mode. depending on the mode, it can either trigger
138 * screen on, off or low power mode and wait for it to complete.
Mathias Agopian041a0752013-03-15 18:31:56 -0700139 * requires ACCESS_SURFACE_FLINGER permission.
140 */
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700141 virtual void setPowerMode(const sp<IBinder>& display, int mode) = 0;
Mathias Agopian3094df32012-06-18 18:06:45 -0700142
Dan Stoza7f7da322014-05-02 15:26:25 -0700143 /* returns information for each configuration of the given display
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700144 * intended to be used to get information about built-in displays */
Dan Stoza7f7da322014-05-02 15:26:25 -0700145 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
146 Vector<DisplayInfo>* configs) = 0;
147
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700148 /* returns display statistics for a given display
149 * intended to be used by the media framework to properly schedule
150 * video frames */
151 virtual status_t getDisplayStats(const sp<IBinder>& display,
152 DisplayStatInfo* stats) = 0;
153
Dan Stoza7f7da322014-05-02 15:26:25 -0700154 /* indicates which of the configurations returned by getDisplayInfo is
155 * currently active */
156 virtual int getActiveConfig(const sp<IBinder>& display) = 0;
157
158 /* specifies which configuration (of those returned by getDisplayInfo)
159 * should be used */
160 virtual status_t setActiveConfig(const sp<IBinder>& display, int id) = 0;
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800161
Michael Wright28f24d02016-07-12 13:30:53 -0700162 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700163 Vector<ui::ColorMode>* outColorModes) = 0;
164 virtual ui::ColorMode getActiveColorMode(const sp<IBinder>& display) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700165 virtual status_t setActiveColorMode(const sp<IBinder>& display,
Peiyong Lin9f034472018-03-28 15:29:00 -0700166 ui::ColorMode colorMode) = 0;
Michael Wright28f24d02016-07-12 13:30:53 -0700167
Chia-I Wuff79ef82018-08-22 15:27:32 -0700168 /**
169 * Capture the specified screen. This requires READ_FRAME_BUFFER
170 * permission. This function will fail if there is a secure window on
171 * screen.
172 *
173 * This function can capture a subregion (the source crop) of the screen.
174 * The subregion can be optionally rotated. It will also be scaled to
175 * match the size of the output buffer.
176 *
Peiyong Lin0e003c92018-09-17 11:09:51 -0700177 * reqDataspace and reqPixelFormat specify the data space and pixel format
178 * of the buffer. The caller should pick the data space and pixel format
179 * that it can consume.
180 *
181 * At the moment, sourceCrop is ignored and is always set to the visible
182 * region (projected display viewport) of the screen.
183 *
184 * reqWidth and reqHeight specifies the size of the buffer. When either
185 * of them is 0, they are set to the size of the logical display viewport.
186 *
187 * When useIdentityTransform is true, layer transformations are disabled.
188 *
189 * rotation specifies the rotation of the source crop (and the pixels in
190 * it) around its center.
191 */
192 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
193 const ui::Dataspace reqDataspace,
194 const ui::PixelFormat reqPixelFormat, Rect sourceCrop,
195 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform,
196 Rotation rotation = eRotateNone) = 0;
197 /**
198 * Capture the specified screen. This requires READ_FRAME_BUFFER
199 * permission. This function will fail if there is a secure window on
200 * screen.
201 *
202 * This function can capture a subregion (the source crop) of the screen
203 * into an sRGB buffer with RGBA_8888 pixel format.
204 * The subregion can be optionally rotated. It will also be scaled to
205 * match the size of the output buffer.
206 *
Chia-I Wuff79ef82018-08-22 15:27:32 -0700207 * At the moment, sourceCrop is ignored and is always set to the visible
208 * region (projected display viewport) of the screen.
209 *
210 * reqWidth and reqHeight specifies the size of the buffer. When either
211 * of them is 0, they are set to the size of the logical display viewport.
212 *
213 * When useIdentityTransform is true, layer transformations are disabled.
214 *
215 * rotation specifies the rotation of the source crop (and the pixels in
216 * it) around its center.
Mathias Agopian041a0752013-03-15 18:31:56 -0700217 */
Chavi Weingarten40482ff2017-11-30 01:51:40 +0000218 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
219 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700220 bool useIdentityTransform, Rotation rotation = eRotateNone) {
221 return captureScreen(display, outBuffer, ui::Dataspace::V0_SRGB, ui::PixelFormat::RGBA_8888,
222 sourceCrop, reqWidth, reqHeight, useIdentityTransform, rotation);
223 }
Svetoslavd85084b2014-03-20 10:28:31 -0700224
Robert Carr578038f2018-03-09 12:25:24 -0800225 /**
226 * Capture a subtree of the layer hierarchy, potentially ignoring the root node.
Peiyong Lin0e003c92018-09-17 11:09:51 -0700227 *
228 * reqDataspace and reqPixelFormat specify the data space and pixel format
229 * of the buffer. The caller should pick the data space and pixel format
230 * that it can consume.
Robert Carr578038f2018-03-09 12:25:24 -0800231 */
chaviwa76b2712017-09-20 12:02:26 -0700232 virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,
Peiyong Lin0e003c92018-09-17 11:09:51 -0700233 sp<GraphicBuffer>* outBuffer, const ui::Dataspace reqDataspace,
234 const ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
Robert Carr578038f2018-03-09 12:25:24 -0800235 float frameScale = 1.0, bool childrenOnly = false) = 0;
chaviwa76b2712017-09-20 12:02:26 -0700236
Peiyong Lin0e003c92018-09-17 11:09:51 -0700237 /**
238 * Capture a subtree of the layer hierarchy into an sRGB buffer with RGBA_8888 pixel format,
239 * potentially ignoring the root node.
240 */
241 status_t captureLayers(const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
242 const Rect& sourceCrop, float frameScale = 1.0,
243 bool childrenOnly = false) {
244 return captureLayers(layerHandleBinder, outBuffer, ui::Dataspace::V0_SRGB,
245 ui::PixelFormat::RGBA_8888, sourceCrop, frameScale, childrenOnly);
246 }
247
Svetoslavd85084b2014-03-20 10:28:31 -0700248 /* Clears the frame statistics for animations.
249 *
250 * Requires the ACCESS_SURFACE_FLINGER permission.
251 */
252 virtual status_t clearAnimationFrameStats() = 0;
253
254 /* Gets the frame statistics for animations.
255 *
256 * Requires the ACCESS_SURFACE_FLINGER permission.
257 */
258 virtual status_t getAnimationFrameStats(FrameStats* outStats) const = 0;
Dan Stozac4f471e2016-03-24 09:31:08 -0700259
260 /* Gets the supported HDR capabilities of the given display.
261 *
262 * Requires the ACCESS_SURFACE_FLINGER permission.
263 */
264 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
265 HdrCapabilities* outCapabilities) const = 0;
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700266
267 virtual status_t enableVSyncInjections(bool enable) = 0;
268
269 virtual status_t injectVSync(nsecs_t when) = 0;
Kalle Raitaa099a242017-01-11 11:17:29 -0800270
271 /* Gets the list of active layers in Z order for debugging purposes
272 *
273 * Requires the ACCESS_SURFACE_FLINGER permission.
274 */
275 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const = 0;
Peiyong Lin0256f722018-08-31 15:45:10 -0700276
Ady Abraham37965d42018-11-01 13:43:32 -0700277 virtual status_t getColorManagement(bool* outGetColorManagement) const = 0;
Peiyong Linc6780972018-10-28 15:24:08 -0700278
279 /* Gets the composition preference of the default data space and default pixel format,
280 * as well as the wide color gamut data space and wide color gamut pixel format.
281 * If the wide color gamut data space is V0_SRGB, then it implies that the platform
282 * has no wide color gamut support.
283 *
284 * Requires the ACCESS_SURFACE_FLINGER permission.
285 */
286 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
287 ui::PixelFormat* defaultPixelFormat,
288 ui::Dataspace* wideColorGamutDataspace,
289 ui::PixelFormat* wideColorGamutPixelFormat) const = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700290 /*
291 * Requires the ACCESS_SURFACE_FLINGER permission.
292 */
293 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
294 ui::PixelFormat* outFormat,
295 ui::Dataspace* outDataspace,
296 uint8_t* outComponentMask) const = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800297
298 /* Turns on the color sampling engine on the display.
299 *
300 * Requires the ACCESS_SURFACE_FLINGER permission.
301 */
302 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
303 uint8_t componentMask,
304 uint64_t maxFrames) const = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700305
306 /* Returns statistics on the color profile of the last frame displayed for a given display
307 *
308 * Requires the ACCESS_SURFACE_FLINGER permission.
309 */
310 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
311 uint64_t timestamp,
312 DisplayedFrameStats* outStats) const = 0;
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800313
314 /*
315 * Gets whether SurfaceFlinger can support protected content in GPU composition.
316 * Requires the ACCESS_SURFACE_FLINGER permission.
317 */
318 virtual status_t getProtectedContentSupport(bool* outSupported) const = 0;
Marissa Wallebc2c052019-01-16 19:16:55 -0800319
320 virtual status_t cacheBuffer(const sp<IBinder>& token, const sp<GraphicBuffer>& buffer,
321 int32_t* outBufferId) = 0;
322
323 virtual status_t uncacheBuffer(const sp<IBinder>& token, int32_t bufferId) = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800324};
325
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800326// ----------------------------------------------------------------------------
327
Mathias Agopian3165cc22012-08-08 19:42:09 -0700328class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800329public:
Ana Krulec13be8ad2018-08-21 02:43:56 +0000330 enum ISurfaceComposerTag {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800331 // Note: BOOT_FINISHED must remain this value, it is called from
332 // Java by ActivityManagerService.
333 BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,
334 CREATE_CONNECTION,
Ana Krulec13be8ad2018-08-21 02:43:56 +0000335 CREATE_GRAPHIC_BUFFER_ALLOC_UNUSED, // unused, fails permissions check
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800336 CREATE_DISPLAY_EVENT_CONNECTION,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700337 CREATE_DISPLAY,
Jesse Hall6c913be2013-08-08 12:15:49 -0700338 DESTROY_DISPLAY,
Mathias Agopiane57f2922012-08-09 16:29:12 -0700339 GET_BUILT_IN_DISPLAY,
340 SET_TRANSACTION_STATE,
341 AUTHENTICATE_SURFACE,
Brian Anderson069b3652016-07-22 10:32:47 -0700342 GET_SUPPORTED_FRAME_TIMESTAMPS,
Dan Stoza7f7da322014-05-02 15:26:25 -0700343 GET_DISPLAY_CONFIGS,
344 GET_ACTIVE_CONFIG,
345 SET_ACTIVE_CONFIG,
Ana Krulec13be8ad2018-08-21 02:43:56 +0000346 CONNECT_DISPLAY_UNUSED, // unused, fails permissions check
Mathias Agopian2a9fc492013-03-01 13:42:57 -0800347 CAPTURE_SCREEN,
chaviwa76b2712017-09-20 12:02:26 -0700348 CAPTURE_LAYERS,
Svetoslavd85084b2014-03-20 10:28:31 -0700349 CLEAR_ANIMATION_FRAME_STATS,
Prashant Malani2c9b11f2014-05-25 01:36:31 -0700350 GET_ANIMATION_FRAME_STATS,
351 SET_POWER_MODE,
Lajos Molnar67d8bd62014-09-11 14:58:45 -0700352 GET_DISPLAY_STATS,
Dan Stozac4f471e2016-03-24 09:31:08 -0700353 GET_HDR_CAPABILITIES,
Michael Wright28f24d02016-07-12 13:30:53 -0700354 GET_DISPLAY_COLOR_MODES,
355 GET_ACTIVE_COLOR_MODE,
356 SET_ACTIVE_COLOR_MODE,
Sahil Dhanjuc1ba5c42016-06-07 20:09:20 -0700357 ENABLE_VSYNC_INJECTIONS,
Robert Carr1db73f62016-12-21 12:58:51 -0800358 INJECT_VSYNC,
Kalle Raitaa099a242017-01-11 11:17:29 -0800359 GET_LAYER_DEBUG_INFO,
Peiyong Lin0256f722018-08-31 15:45:10 -0700360 GET_COMPOSITION_PREFERENCE,
Ady Abraham37965d42018-11-01 13:43:32 -0700361 GET_COLOR_MANAGEMENT,
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700362 GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES,
Kevin DuBois74e53772018-11-19 10:52:38 -0800363 SET_DISPLAY_CONTENT_SAMPLING_ENABLED,
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700364 GET_DISPLAYED_CONTENT_SAMPLE,
Peiyong Lin3c2791e2019-01-14 17:05:18 -0800365 GET_PROTECTED_CONTENT_SUPPORT,
Marissa Wallebc2c052019-01-16 19:16:55 -0800366 CACHE_BUFFER,
367 UNCACHE_BUFFER,
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800368 };
369
Mathias Agopian3165cc22012-08-08 19:42:09 -0700370 virtual status_t onTransact(uint32_t code, const Parcel& data,
371 Parcel* reply, uint32_t flags = 0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800372};
373
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800374// ----------------------------------------------------------------------------
375
376}; // namespace android
377
Mathias Agopian90ac7992012-02-25 18:48:35 -0800378#endif // ANDROID_GUI_ISURFACE_COMPOSER_H