1 /*
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 // tag as surfaceflinger
18 #define LOG_TAG "SurfaceFlinger"
19
20 #include <stdint.h>
21 #include <sys/types.h>
22
23 #include <binder/Parcel.h>
24 #include <binder/IPCThreadState.h>
25 #include <binder/IServiceManager.h>
26
27 #include <gui/IDisplayEventConnection.h>
28 #include <gui/IGraphicBufferProducer.h>
29 #include <gui/ISurfaceComposer.h>
30 #include <gui/ISurfaceComposerClient.h>
31 #include <gui/LayerDebugInfo.h>
32 #include <gui/LayerState.h>
33
34 #include <system/graphics.h>
35
36 #include <ui/DisplayInfo.h>
37 #include <ui/DisplayStatInfo.h>
38 #include <ui/HdrCapabilities.h>
39
40 #include <utils/Log.h>
41
42 // ---------------------------------------------------------------------------
43
44 namespace android {
45
46 using ui::ColorMode;
47
48 class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
49 {
50 public:
BpSurfaceComposer(const sp<IBinder> & impl)51 explicit BpSurfaceComposer(const sp<IBinder>& impl)
52 : BpInterface<ISurfaceComposer>(impl)
53 {
54 }
55
56 virtual ~BpSurfaceComposer();
57
createConnection()58 virtual sp<ISurfaceComposerClient> createConnection()
59 {
60 Parcel data, reply;
61 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
62 remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
63 return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
64 }
65
createScopedConnection(const sp<IGraphicBufferProducer> & parent)66 virtual sp<ISurfaceComposerClient> createScopedConnection(
67 const sp<IGraphicBufferProducer>& parent)
68 {
69 Parcel data, reply;
70 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
71 data.writeStrongBinder(IInterface::asBinder(parent));
72 remote()->transact(BnSurfaceComposer::CREATE_SCOPED_CONNECTION, data, &reply);
73 return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
74 }
75
setTransactionState(const Vector<ComposerState> & state,const Vector<DisplayState> & displays,uint32_t flags)76 virtual void setTransactionState(
77 const Vector<ComposerState>& state,
78 const Vector<DisplayState>& displays,
79 uint32_t flags)
80 {
81 Parcel data, reply;
82 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
83
84 data.writeUint32(static_cast<uint32_t>(state.size()));
85 for (const auto& s : state) {
86 s.write(data);
87 }
88
89 data.writeUint32(static_cast<uint32_t>(displays.size()));
90 for (const auto& d : displays) {
91 d.write(data);
92 }
93
94 data.writeUint32(flags);
95 remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
96 }
97
bootFinished()98 virtual void bootFinished()
99 {
100 Parcel data, reply;
101 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
102 remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);
103 }
104
captureScreen(const sp<IBinder> & display,sp<GraphicBuffer> * outBuffer,bool & outCapturedSecureLayers,Rect sourceCrop,uint32_t reqWidth,uint32_t reqHeight,int32_t minLayerZ,int32_t maxLayerZ,bool useIdentityTransform,ISurfaceComposer::Rotation rotation,bool captureSecureLayers)105 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
106 bool& outCapturedSecureLayers,
107 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
108 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,
109 ISurfaceComposer::Rotation rotation, bool captureSecureLayers) {
110 Parcel data, reply;
111 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
112 data.writeStrongBinder(display);
113 data.write(sourceCrop);
114 data.writeUint32(reqWidth);
115 data.writeUint32(reqHeight);
116 data.writeInt32(minLayerZ);
117 data.writeInt32(maxLayerZ);
118 data.writeInt32(static_cast<int32_t>(useIdentityTransform));
119 data.writeInt32(static_cast<int32_t>(rotation));
120 data.writeInt32(static_cast<int32_t>(captureSecureLayers));
121 status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);
122
123 if (err != NO_ERROR) {
124 return err;
125 }
126
127 err = reply.readInt32();
128 if (err != NO_ERROR) {
129 return err;
130 }
131
132 *outBuffer = new GraphicBuffer();
133 reply.read(**outBuffer);
134 outCapturedSecureLayers = reply.readBool();
135
136 return err;
137 }
138
captureLayers(const sp<IBinder> & layerHandleBinder,sp<GraphicBuffer> * outBuffer,const Rect & sourceCrop,float frameScale,bool childrenOnly)139 virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,
140 sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,
141 float frameScale, bool childrenOnly) {
142 Parcel data, reply;
143 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
144 data.writeStrongBinder(layerHandleBinder);
145 data.write(sourceCrop);
146 data.writeFloat(frameScale);
147 data.writeBool(childrenOnly);
148 status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);
149
150 if (err != NO_ERROR) {
151 return err;
152 }
153
154 err = reply.readInt32();
155 if (err != NO_ERROR) {
156 return err;
157 }
158
159 *outBuffer = new GraphicBuffer();
160 reply.read(**outBuffer);
161
162 return err;
163 }
164
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> & bufferProducer) const165 virtual bool authenticateSurfaceTexture(
166 const sp<IGraphicBufferProducer>& bufferProducer) const
167 {
168 Parcel data, reply;
169 int err = NO_ERROR;
170 err = data.writeInterfaceToken(
171 ISurfaceComposer::getInterfaceDescriptor());
172 if (err != NO_ERROR) {
173 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "
174 "interface descriptor: %s (%d)", strerror(-err), -err);
175 return false;
176 }
177 err = data.writeStrongBinder(IInterface::asBinder(bufferProducer));
178 if (err != NO_ERROR) {
179 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "
180 "strong binder to parcel: %s (%d)", strerror(-err), -err);
181 return false;
182 }
183 err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data,
184 &reply);
185 if (err != NO_ERROR) {
186 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "
187 "performing transaction: %s (%d)", strerror(-err), -err);
188 return false;
189 }
190 int32_t result = 0;
191 err = reply.readInt32(&result);
192 if (err != NO_ERROR) {
193 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "
194 "retrieving result: %s (%d)", strerror(-err), -err);
195 return false;
196 }
197 return result != 0;
198 }
199
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported) const200 virtual status_t getSupportedFrameTimestamps(
201 std::vector<FrameEvent>* outSupported) const {
202 if (!outSupported) {
203 return UNEXPECTED_NULL;
204 }
205 outSupported->clear();
206
207 Parcel data, reply;
208
209 status_t err = data.writeInterfaceToken(
210 ISurfaceComposer::getInterfaceDescriptor());
211 if (err != NO_ERROR) {
212 return err;
213 }
214
215 err = remote()->transact(
216 BnSurfaceComposer::GET_SUPPORTED_FRAME_TIMESTAMPS,
217 data, &reply);
218 if (err != NO_ERROR) {
219 return err;
220 }
221
222 int32_t result = 0;
223 err = reply.readInt32(&result);
224 if (err != NO_ERROR) {
225 return err;
226 }
227 if (result != NO_ERROR) {
228 return result;
229 }
230
231 std::vector<int32_t> supported;
232 err = reply.readInt32Vector(&supported);
233 if (err != NO_ERROR) {
234 return err;
235 }
236
237 outSupported->reserve(supported.size());
238 for (int32_t s : supported) {
239 outSupported->push_back(static_cast<FrameEvent>(s));
240 }
241 return NO_ERROR;
242 }
243
createDisplayEventConnection(VsyncSource vsyncSource)244 virtual sp<IDisplayEventConnection> createDisplayEventConnection(VsyncSource vsyncSource)
245 {
246 Parcel data, reply;
247 sp<IDisplayEventConnection> result;
248 int err = data.writeInterfaceToken(
249 ISurfaceComposer::getInterfaceDescriptor());
250 if (err != NO_ERROR) {
251 return result;
252 }
253 data.writeInt32(static_cast<int32_t>(vsyncSource));
254 err = remote()->transact(
255 BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION,
256 data, &reply);
257 if (err != NO_ERROR) {
258 ALOGE("ISurfaceComposer::createDisplayEventConnection: error performing "
259 "transaction: %s (%d)", strerror(-err), -err);
260 return result;
261 }
262 result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder());
263 return result;
264 }
265
createDisplay(const String8 & displayName,bool secure)266 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure)
267 {
268 Parcel data, reply;
269 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
270 data.writeString8(displayName);
271 data.writeInt32(secure ? 1 : 0);
272 remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply);
273 return reply.readStrongBinder();
274 }
275
destroyDisplay(const sp<IBinder> & display)276 virtual void destroyDisplay(const sp<IBinder>& display)
277 {
278 Parcel data, reply;
279 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
280 data.writeStrongBinder(display);
281 remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply);
282 }
283
getBuiltInDisplay(int32_t id)284 virtual sp<IBinder> getBuiltInDisplay(int32_t id)
285 {
286 Parcel data, reply;
287 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
288 data.writeInt32(id);
289 remote()->transact(BnSurfaceComposer::GET_BUILT_IN_DISPLAY, data, &reply);
290 return reply.readStrongBinder();
291 }
292
setPowerMode(const sp<IBinder> & display,int mode)293 virtual void setPowerMode(const sp<IBinder>& display, int mode)
294 {
295 Parcel data, reply;
296 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
297 data.writeStrongBinder(display);
298 data.writeInt32(mode);
299 remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply);
300 }
301
getDisplayConfigs(const sp<IBinder> & display,Vector<DisplayInfo> * configs)302 virtual status_t getDisplayConfigs(const sp<IBinder>& display,
303 Vector<DisplayInfo>* configs)
304 {
305 Parcel data, reply;
306 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
307 data.writeStrongBinder(display);
308 remote()->transact(BnSurfaceComposer::GET_DISPLAY_CONFIGS, data, &reply);
309 status_t result = reply.readInt32();
310 if (result == NO_ERROR) {
311 size_t numConfigs = reply.readUint32();
312 configs->clear();
313 configs->resize(numConfigs);
314 for (size_t c = 0; c < numConfigs; ++c) {
315 memcpy(&(configs->editItemAt(c)),
316 reply.readInplace(sizeof(DisplayInfo)),
317 sizeof(DisplayInfo));
318 }
319 }
320 return result;
321 }
322
getDisplayStats(const sp<IBinder> & display,DisplayStatInfo * stats)323 virtual status_t getDisplayStats(const sp<IBinder>& display,
324 DisplayStatInfo* stats)
325 {
326 Parcel data, reply;
327 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
328 data.writeStrongBinder(display);
329 remote()->transact(BnSurfaceComposer::GET_DISPLAY_STATS, data, &reply);
330 status_t result = reply.readInt32();
331 if (result == NO_ERROR) {
332 memcpy(stats,
333 reply.readInplace(sizeof(DisplayStatInfo)),
334 sizeof(DisplayStatInfo));
335 }
336 return result;
337 }
338
getActiveConfig(const sp<IBinder> & display)339 virtual int getActiveConfig(const sp<IBinder>& display)
340 {
341 Parcel data, reply;
342 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
343 data.writeStrongBinder(display);
344 remote()->transact(BnSurfaceComposer::GET_ACTIVE_CONFIG, data, &reply);
345 return reply.readInt32();
346 }
347
setActiveConfig(const sp<IBinder> & display,int id)348 virtual status_t setActiveConfig(const sp<IBinder>& display, int id)
349 {
350 Parcel data, reply;
351 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
352 data.writeStrongBinder(display);
353 data.writeInt32(id);
354 remote()->transact(BnSurfaceComposer::SET_ACTIVE_CONFIG, data, &reply);
355 return reply.readInt32();
356 }
357
getDisplayColorModes(const sp<IBinder> & display,Vector<ColorMode> * outColorModes)358 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
359 Vector<ColorMode>* outColorModes) {
360 Parcel data, reply;
361 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
362 if (result != NO_ERROR) {
363 ALOGE("getDisplayColorModes failed to writeInterfaceToken: %d", result);
364 return result;
365 }
366 result = data.writeStrongBinder(display);
367 if (result != NO_ERROR) {
368 ALOGE("getDisplayColorModes failed to writeStrongBinder: %d", result);
369 return result;
370 }
371 result = remote()->transact(BnSurfaceComposer::GET_DISPLAY_COLOR_MODES, data, &reply);
372 if (result != NO_ERROR) {
373 ALOGE("getDisplayColorModes failed to transact: %d", result);
374 return result;
375 }
376 result = static_cast<status_t>(reply.readInt32());
377 if (result == NO_ERROR) {
378 size_t numModes = reply.readUint32();
379 outColorModes->clear();
380 outColorModes->resize(numModes);
381 for (size_t i = 0; i < numModes; ++i) {
382 outColorModes->replaceAt(static_cast<ColorMode>(reply.readInt32()), i);
383 }
384 }
385 return result;
386 }
387
getActiveColorMode(const sp<IBinder> & display)388 virtual ColorMode getActiveColorMode(const sp<IBinder>& display) {
389 Parcel data, reply;
390 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
391 if (result != NO_ERROR) {
392 ALOGE("getActiveColorMode failed to writeInterfaceToken: %d", result);
393 return static_cast<ColorMode>(result);
394 }
395 result = data.writeStrongBinder(display);
396 if (result != NO_ERROR) {
397 ALOGE("getActiveColorMode failed to writeStrongBinder: %d", result);
398 return static_cast<ColorMode>(result);
399 }
400 result = remote()->transact(BnSurfaceComposer::GET_ACTIVE_COLOR_MODE, data, &reply);
401 if (result != NO_ERROR) {
402 ALOGE("getActiveColorMode failed to transact: %d", result);
403 return static_cast<ColorMode>(result);
404 }
405 return static_cast<ColorMode>(reply.readInt32());
406 }
407
setActiveColorMode(const sp<IBinder> & display,ColorMode colorMode)408 virtual status_t setActiveColorMode(const sp<IBinder>& display,
409 ColorMode colorMode) {
410 Parcel data, reply;
411 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
412 if (result != NO_ERROR) {
413 ALOGE("setActiveColorMode failed to writeInterfaceToken: %d", result);
414 return result;
415 }
416 result = data.writeStrongBinder(display);
417 if (result != NO_ERROR) {
418 ALOGE("setActiveColorMode failed to writeStrongBinder: %d", result);
419 return result;
420 }
421 result = data.writeInt32(static_cast<int32_t>(colorMode));
422 if (result != NO_ERROR) {
423 ALOGE("setActiveColorMode failed to writeInt32: %d", result);
424 return result;
425 }
426 result = remote()->transact(BnSurfaceComposer::SET_ACTIVE_COLOR_MODE, data, &reply);
427 if (result != NO_ERROR) {
428 ALOGE("setActiveColorMode failed to transact: %d", result);
429 return result;
430 }
431 return static_cast<status_t>(reply.readInt32());
432 }
433
clearAnimationFrameStats()434 virtual status_t clearAnimationFrameStats() {
435 Parcel data, reply;
436 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
437 remote()->transact(BnSurfaceComposer::CLEAR_ANIMATION_FRAME_STATS, data, &reply);
438 return reply.readInt32();
439 }
440
getAnimationFrameStats(FrameStats * outStats) const441 virtual status_t getAnimationFrameStats(FrameStats* outStats) const {
442 Parcel data, reply;
443 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
444 remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply);
445 reply.read(*outStats);
446 return reply.readInt32();
447 }
448
getHdrCapabilities(const sp<IBinder> & display,HdrCapabilities * outCapabilities) const449 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
450 HdrCapabilities* outCapabilities) const {
451 Parcel data, reply;
452 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
453 status_t result = data.writeStrongBinder(display);
454 if (result != NO_ERROR) {
455 ALOGE("getHdrCapabilities failed to writeStrongBinder: %d", result);
456 return result;
457 }
458 result = remote()->transact(BnSurfaceComposer::GET_HDR_CAPABILITIES,
459 data, &reply);
460 if (result != NO_ERROR) {
461 ALOGE("getHdrCapabilities failed to transact: %d", result);
462 return result;
463 }
464 result = reply.readInt32();
465 if (result == NO_ERROR) {
466 result = reply.read(*outCapabilities);
467 }
468 return result;
469 }
470
enableVSyncInjections(bool enable)471 virtual status_t enableVSyncInjections(bool enable) {
472 Parcel data, reply;
473 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
474 if (result != NO_ERROR) {
475 ALOGE("enableVSyncInjections failed to writeInterfaceToken: %d", result);
476 return result;
477 }
478 result = data.writeBool(enable);
479 if (result != NO_ERROR) {
480 ALOGE("enableVSyncInjections failed to writeBool: %d", result);
481 return result;
482 }
483 result = remote()->transact(BnSurfaceComposer::ENABLE_VSYNC_INJECTIONS,
484 data, &reply, TF_ONE_WAY);
485 if (result != NO_ERROR) {
486 ALOGE("enableVSyncInjections failed to transact: %d", result);
487 return result;
488 }
489 return result;
490 }
491
injectVSync(nsecs_t when)492 virtual status_t injectVSync(nsecs_t when) {
493 Parcel data, reply;
494 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
495 if (result != NO_ERROR) {
496 ALOGE("injectVSync failed to writeInterfaceToken: %d", result);
497 return result;
498 }
499 result = data.writeInt64(when);
500 if (result != NO_ERROR) {
501 ALOGE("injectVSync failed to writeInt64: %d", result);
502 return result;
503 }
504 result = remote()->transact(BnSurfaceComposer::INJECT_VSYNC, data, &reply, TF_ONE_WAY);
505 if (result != NO_ERROR) {
506 ALOGE("injectVSync failed to transact: %d", result);
507 return result;
508 }
509 return result;
510 }
511
getLayerDebugInfo(std::vector<LayerDebugInfo> * outLayers)512 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers)
513 {
514 if (!outLayers) {
515 return UNEXPECTED_NULL;
516 }
517
518 Parcel data, reply;
519
520 status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
521 if (err != NO_ERROR) {
522 return err;
523 }
524
525 err = remote()->transact(BnSurfaceComposer::GET_LAYER_DEBUG_INFO, data, &reply);
526 if (err != NO_ERROR) {
527 return err;
528 }
529
530 int32_t result = 0;
531 err = reply.readInt32(&result);
532 if (err != NO_ERROR) {
533 return err;
534 }
535 if (result != NO_ERROR) {
536 return result;
537 }
538
539 outLayers->clear();
540 return reply.readParcelableVector(outLayers);
541 }
542 };
543
544 // Out-of-line virtual method definition to trigger vtable emission in this
545 // translation unit (see clang warning -Wweak-vtables)
~BpSurfaceComposer()546 BpSurfaceComposer::~BpSurfaceComposer() {}
547
548 IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer");
549
550 // ----------------------------------------------------------------------
551
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)552 status_t BnSurfaceComposer::onTransact(
553 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
554 {
555 switch(code) {
556 case CREATE_CONNECTION: {
557 CHECK_INTERFACE(ISurfaceComposer, data, reply);
558 sp<IBinder> b = IInterface::asBinder(createConnection());
559 reply->writeStrongBinder(b);
560 return NO_ERROR;
561 }
562 case CREATE_SCOPED_CONNECTION: {
563 CHECK_INTERFACE(ISurfaceComposer, data, reply);
564 sp<IGraphicBufferProducer> bufferProducer =
565 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
566 sp<IBinder> b = IInterface::asBinder(createScopedConnection(bufferProducer));
567 reply->writeStrongBinder(b);
568 return NO_ERROR;
569 }
570 case SET_TRANSACTION_STATE: {
571 CHECK_INTERFACE(ISurfaceComposer, data, reply);
572
573 size_t count = data.readUint32();
574 if (count > data.dataSize()) {
575 return BAD_VALUE;
576 }
577 ComposerState s;
578 Vector<ComposerState> state;
579 state.setCapacity(count);
580 for (size_t i = 0; i < count; i++) {
581 if (s.read(data) == BAD_VALUE) {
582 return BAD_VALUE;
583 }
584 state.add(s);
585 }
586
587 count = data.readUint32();
588 if (count > data.dataSize()) {
589 return BAD_VALUE;
590 }
591 DisplayState d;
592 Vector<DisplayState> displays;
593 displays.setCapacity(count);
594 for (size_t i = 0; i < count; i++) {
595 if (d.read(data) == BAD_VALUE) {
596 return BAD_VALUE;
597 }
598 displays.add(d);
599 }
600
601 uint32_t stateFlags = data.readUint32();
602 setTransactionState(state, displays, stateFlags);
603 return NO_ERROR;
604 }
605 case BOOT_FINISHED: {
606 CHECK_INTERFACE(ISurfaceComposer, data, reply);
607 bootFinished();
608 return NO_ERROR;
609 }
610 case CAPTURE_SCREEN: {
611 CHECK_INTERFACE(ISurfaceComposer, data, reply);
612 sp<IBinder> display = data.readStrongBinder();
613 sp<GraphicBuffer> outBuffer;
614 Rect sourceCrop(Rect::EMPTY_RECT);
615 data.read(sourceCrop);
616 uint32_t reqWidth = data.readUint32();
617 uint32_t reqHeight = data.readUint32();
618 int32_t minLayerZ = data.readInt32();
619 int32_t maxLayerZ = data.readInt32();
620 bool useIdentityTransform = static_cast<bool>(data.readInt32());
621 int32_t rotation = data.readInt32();
622 bool captureSecureLayers = static_cast<bool>(data.readInt32());
623
624 bool capturedSecureLayers = false;
625 status_t res = captureScreen(display, &outBuffer, capturedSecureLayers, sourceCrop, reqWidth,
626 reqHeight, minLayerZ, maxLayerZ, useIdentityTransform,
627 static_cast<ISurfaceComposer::Rotation>(rotation), captureSecureLayers);
628
629 reply->writeInt32(res);
630 if (res == NO_ERROR) {
631 reply->write(*outBuffer);
632 reply->writeBool(capturedSecureLayers);
633 }
634 return NO_ERROR;
635 }
636 case CAPTURE_LAYERS: {
637 CHECK_INTERFACE(ISurfaceComposer, data, reply);
638 sp<IBinder> layerHandleBinder = data.readStrongBinder();
639 sp<GraphicBuffer> outBuffer;
640 Rect sourceCrop(Rect::EMPTY_RECT);
641 data.read(sourceCrop);
642 float frameScale = data.readFloat();
643 bool childrenOnly = data.readBool();
644
645 status_t res = captureLayers(layerHandleBinder, &outBuffer, sourceCrop, frameScale,
646 childrenOnly);
647 reply->writeInt32(res);
648 if (res == NO_ERROR) {
649 reply->write(*outBuffer);
650 }
651 return NO_ERROR;
652 }
653 case AUTHENTICATE_SURFACE: {
654 CHECK_INTERFACE(ISurfaceComposer, data, reply);
655 sp<IGraphicBufferProducer> bufferProducer =
656 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
657 int32_t result = authenticateSurfaceTexture(bufferProducer) ? 1 : 0;
658 reply->writeInt32(result);
659 return NO_ERROR;
660 }
661 case GET_SUPPORTED_FRAME_TIMESTAMPS: {
662 CHECK_INTERFACE(ISurfaceComposer, data, reply);
663 std::vector<FrameEvent> supportedTimestamps;
664 status_t result = getSupportedFrameTimestamps(&supportedTimestamps);
665 status_t err = reply->writeInt32(result);
666 if (err != NO_ERROR) {
667 return err;
668 }
669 if (result != NO_ERROR) {
670 return result;
671 }
672
673 std::vector<int32_t> supported;
674 supported.reserve(supportedTimestamps.size());
675 for (FrameEvent s : supportedTimestamps) {
676 supported.push_back(static_cast<int32_t>(s));
677 }
678 return reply->writeInt32Vector(supported);
679 }
680 case CREATE_DISPLAY_EVENT_CONNECTION: {
681 CHECK_INTERFACE(ISurfaceComposer, data, reply);
682 sp<IDisplayEventConnection> connection(createDisplayEventConnection(
683 static_cast<ISurfaceComposer::VsyncSource>(data.readInt32())));
684 reply->writeStrongBinder(IInterface::asBinder(connection));
685 return NO_ERROR;
686 }
687 case CREATE_DISPLAY: {
688 CHECK_INTERFACE(ISurfaceComposer, data, reply);
689 String8 displayName = data.readString8();
690 bool secure = bool(data.readInt32());
691 sp<IBinder> display(createDisplay(displayName, secure));
692 reply->writeStrongBinder(display);
693 return NO_ERROR;
694 }
695 case DESTROY_DISPLAY: {
696 CHECK_INTERFACE(ISurfaceComposer, data, reply);
697 sp<IBinder> display = data.readStrongBinder();
698 destroyDisplay(display);
699 return NO_ERROR;
700 }
701 case GET_BUILT_IN_DISPLAY: {
702 CHECK_INTERFACE(ISurfaceComposer, data, reply);
703 int32_t id = data.readInt32();
704 sp<IBinder> display(getBuiltInDisplay(id));
705 reply->writeStrongBinder(display);
706 return NO_ERROR;
707 }
708 case GET_DISPLAY_CONFIGS: {
709 CHECK_INTERFACE(ISurfaceComposer, data, reply);
710 Vector<DisplayInfo> configs;
711 sp<IBinder> display = data.readStrongBinder();
712 status_t result = getDisplayConfigs(display, &configs);
713 reply->writeInt32(result);
714 if (result == NO_ERROR) {
715 reply->writeUint32(static_cast<uint32_t>(configs.size()));
716 for (size_t c = 0; c < configs.size(); ++c) {
717 memcpy(reply->writeInplace(sizeof(DisplayInfo)),
718 &configs[c], sizeof(DisplayInfo));
719 }
720 }
721 return NO_ERROR;
722 }
723 case GET_DISPLAY_STATS: {
724 CHECK_INTERFACE(ISurfaceComposer, data, reply);
725 DisplayStatInfo stats;
726 sp<IBinder> display = data.readStrongBinder();
727 status_t result = getDisplayStats(display, &stats);
728 reply->writeInt32(result);
729 if (result == NO_ERROR) {
730 memcpy(reply->writeInplace(sizeof(DisplayStatInfo)),
731 &stats, sizeof(DisplayStatInfo));
732 }
733 return NO_ERROR;
734 }
735 case GET_ACTIVE_CONFIG: {
736 CHECK_INTERFACE(ISurfaceComposer, data, reply);
737 sp<IBinder> display = data.readStrongBinder();
738 int id = getActiveConfig(display);
739 reply->writeInt32(id);
740 return NO_ERROR;
741 }
742 case SET_ACTIVE_CONFIG: {
743 CHECK_INTERFACE(ISurfaceComposer, data, reply);
744 sp<IBinder> display = data.readStrongBinder();
745 int id = data.readInt32();
746 status_t result = setActiveConfig(display, id);
747 reply->writeInt32(result);
748 return NO_ERROR;
749 }
750 case GET_DISPLAY_COLOR_MODES: {
751 CHECK_INTERFACE(ISurfaceComposer, data, reply);
752 Vector<ColorMode> colorModes;
753 sp<IBinder> display = nullptr;
754 status_t result = data.readStrongBinder(&display);
755 if (result != NO_ERROR) {
756 ALOGE("getDisplayColorModes failed to readStrongBinder: %d", result);
757 return result;
758 }
759 result = getDisplayColorModes(display, &colorModes);
760 reply->writeInt32(result);
761 if (result == NO_ERROR) {
762 reply->writeUint32(static_cast<uint32_t>(colorModes.size()));
763 for (size_t i = 0; i < colorModes.size(); ++i) {
764 reply->writeInt32(static_cast<int32_t>(colorModes[i]));
765 }
766 }
767 return NO_ERROR;
768 }
769 case GET_ACTIVE_COLOR_MODE: {
770 CHECK_INTERFACE(ISurfaceComposer, data, reply);
771 sp<IBinder> display = nullptr;
772 status_t result = data.readStrongBinder(&display);
773 if (result != NO_ERROR) {
774 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);
775 return result;
776 }
777 ColorMode colorMode = getActiveColorMode(display);
778 result = reply->writeInt32(static_cast<int32_t>(colorMode));
779 return result;
780 }
781 case SET_ACTIVE_COLOR_MODE: {
782 CHECK_INTERFACE(ISurfaceComposer, data, reply);
783 sp<IBinder> display = nullptr;
784 status_t result = data.readStrongBinder(&display);
785 if (result != NO_ERROR) {
786 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);
787 return result;
788 }
789 int32_t colorModeInt = 0;
790 result = data.readInt32(&colorModeInt);
791 if (result != NO_ERROR) {
792 ALOGE("setActiveColorMode failed to readInt32: %d", result);
793 return result;
794 }
795 result = setActiveColorMode(display,
796 static_cast<ColorMode>(colorModeInt));
797 result = reply->writeInt32(result);
798 return result;
799 }
800 case CLEAR_ANIMATION_FRAME_STATS: {
801 CHECK_INTERFACE(ISurfaceComposer, data, reply);
802 status_t result = clearAnimationFrameStats();
803 reply->writeInt32(result);
804 return NO_ERROR;
805 }
806 case GET_ANIMATION_FRAME_STATS: {
807 CHECK_INTERFACE(ISurfaceComposer, data, reply);
808 FrameStats stats;
809 status_t result = getAnimationFrameStats(&stats);
810 reply->write(stats);
811 reply->writeInt32(result);
812 return NO_ERROR;
813 }
814 case SET_POWER_MODE: {
815 CHECK_INTERFACE(ISurfaceComposer, data, reply);
816 sp<IBinder> display = data.readStrongBinder();
817 int32_t mode = data.readInt32();
818 setPowerMode(display, mode);
819 return NO_ERROR;
820 }
821 case GET_HDR_CAPABILITIES: {
822 CHECK_INTERFACE(ISurfaceComposer, data, reply);
823 sp<IBinder> display = nullptr;
824 status_t result = data.readStrongBinder(&display);
825 if (result != NO_ERROR) {
826 ALOGE("getHdrCapabilities failed to readStrongBinder: %d",
827 result);
828 return result;
829 }
830 HdrCapabilities capabilities;
831 result = getHdrCapabilities(display, &capabilities);
832 reply->writeInt32(result);
833 if (result == NO_ERROR) {
834 reply->write(capabilities);
835 }
836 return NO_ERROR;
837 }
838 case ENABLE_VSYNC_INJECTIONS: {
839 CHECK_INTERFACE(ISurfaceComposer, data, reply);
840 bool enable = false;
841 status_t result = data.readBool(&enable);
842 if (result != NO_ERROR) {
843 ALOGE("enableVSyncInjections failed to readBool: %d", result);
844 return result;
845 }
846 return enableVSyncInjections(enable);
847 }
848 case INJECT_VSYNC: {
849 CHECK_INTERFACE(ISurfaceComposer, data, reply);
850 int64_t when = 0;
851 status_t result = data.readInt64(&when);
852 if (result != NO_ERROR) {
853 ALOGE("enableVSyncInjections failed to readInt64: %d", result);
854 return result;
855 }
856 return injectVSync(when);
857 }
858 case GET_LAYER_DEBUG_INFO: {
859 CHECK_INTERFACE(ISurfaceComposer, data, reply);
860 std::vector<LayerDebugInfo> outLayers;
861 status_t result = getLayerDebugInfo(&outLayers);
862 reply->writeInt32(result);
863 if (result == NO_ERROR)
864 {
865 result = reply->writeParcelableVector(outLayers);
866 }
867 return result;
868 }
869 default: {
870 return BBinder::onTransact(code, data, reply, flags);
871 }
872 }
873 }
874
875 // ----------------------------------------------------------------------------
876
877 };
878