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/IRegionSamplingListener.h>
30 #include <gui/ISurfaceComposer.h>
31 #include <gui/ISurfaceComposerClient.h>
32 #include <gui/LayerDebugInfo.h>
33 #include <gui/LayerState.h>
34
35 #include <system/graphics.h>
36
37 #include <ui/DisplayConfig.h>
38 #include <ui/DisplayInfo.h>
39 #include <ui/DisplayStatInfo.h>
40 #include <ui/DisplayState.h>
41 #include <ui/HdrCapabilities.h>
42
43 #include <utils/Log.h>
44
45 // ---------------------------------------------------------------------------
46
47 namespace android {
48
49 using ui::ColorMode;
50
51 class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
52 {
53 public:
BpSurfaceComposer(const sp<IBinder> & impl)54 explicit BpSurfaceComposer(const sp<IBinder>& impl)
55 : BpInterface<ISurfaceComposer>(impl)
56 {
57 }
58
59 virtual ~BpSurfaceComposer();
60
createConnection()61 virtual sp<ISurfaceComposerClient> createConnection()
62 {
63 Parcel data, reply;
64 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
65 remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
66 return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
67 }
68
setTransactionState(const Vector<ComposerState> & state,const Vector<DisplayState> & displays,uint32_t flags,const sp<IBinder> & applyToken,const InputWindowCommands & commands,int64_t desiredPresentTime,const client_cache_t & uncacheBuffer,bool hasListenerCallbacks,const std::vector<ListenerCallbacks> & listenerCallbacks)69 virtual void setTransactionState(const Vector<ComposerState>& state,
70 const Vector<DisplayState>& displays, uint32_t flags,
71 const sp<IBinder>& applyToken,
72 const InputWindowCommands& commands,
73 int64_t desiredPresentTime,
74 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
75 const std::vector<ListenerCallbacks>& listenerCallbacks) {
76 Parcel data, reply;
77 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
78
79 data.writeUint32(static_cast<uint32_t>(state.size()));
80 for (const auto& s : state) {
81 s.write(data);
82 }
83
84 data.writeUint32(static_cast<uint32_t>(displays.size()));
85 for (const auto& d : displays) {
86 d.write(data);
87 }
88
89 data.writeUint32(flags);
90 data.writeStrongBinder(applyToken);
91 commands.write(data);
92 data.writeInt64(desiredPresentTime);
93 data.writeStrongBinder(uncacheBuffer.token.promote());
94 data.writeUint64(uncacheBuffer.id);
95 data.writeBool(hasListenerCallbacks);
96
97 if (data.writeVectorSize(listenerCallbacks) == NO_ERROR) {
98 for (const auto& [listener, callbackIds] : listenerCallbacks) {
99 data.writeStrongBinder(listener);
100 data.writeInt64Vector(callbackIds);
101 }
102 }
103
104 remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
105 }
106
bootFinished()107 virtual void bootFinished()
108 {
109 Parcel data, reply;
110 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
111 remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);
112 }
113
captureScreen(const sp<IBinder> & display,sp<GraphicBuffer> * outBuffer,bool & outCapturedSecureLayers,ui::Dataspace reqDataspace,ui::PixelFormat reqPixelFormat,const Rect & sourceCrop,uint32_t reqWidth,uint32_t reqHeight,bool useIdentityTransform,ui::Rotation rotation,bool captureSecureLayers)114 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,
115 bool& outCapturedSecureLayers, ui::Dataspace reqDataspace,
116 ui::PixelFormat reqPixelFormat, const Rect& sourceCrop,
117 uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform,
118 ui::Rotation rotation, bool captureSecureLayers) {
119 Parcel data, reply;
120 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
121 data.writeStrongBinder(display);
122 data.writeInt32(static_cast<int32_t>(reqDataspace));
123 data.writeInt32(static_cast<int32_t>(reqPixelFormat));
124 data.write(sourceCrop);
125 data.writeUint32(reqWidth);
126 data.writeUint32(reqHeight);
127 data.writeInt32(static_cast<int32_t>(useIdentityTransform));
128 data.writeInt32(static_cast<int32_t>(rotation));
129 data.writeInt32(static_cast<int32_t>(captureSecureLayers));
130 status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);
131 if (result != NO_ERROR) {
132 ALOGE("captureScreen failed to transact: %d", result);
133 return result;
134 }
135 result = reply.readInt32();
136 if (result != NO_ERROR) {
137 ALOGE("captureScreen failed to readInt32: %d", result);
138 return result;
139 }
140
141 *outBuffer = new GraphicBuffer();
142 reply.read(**outBuffer);
143 outCapturedSecureLayers = reply.readBool();
144
145 return result;
146 }
147
captureScreen(uint64_t displayOrLayerStack,ui::Dataspace * outDataspace,sp<GraphicBuffer> * outBuffer)148 virtual status_t captureScreen(uint64_t displayOrLayerStack, ui::Dataspace* outDataspace,
149 sp<GraphicBuffer>* outBuffer) {
150 Parcel data, reply;
151 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
152 data.writeUint64(displayOrLayerStack);
153 status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN_BY_ID, data, &reply);
154 if (result != NO_ERROR) {
155 ALOGE("captureScreen failed to transact: %d", result);
156 return result;
157 }
158 result = reply.readInt32();
159 if (result != NO_ERROR) {
160 ALOGE("captureScreen failed to readInt32: %d", result);
161 return result;
162 }
163
164 *outDataspace = static_cast<ui::Dataspace>(reply.readInt32());
165 *outBuffer = new GraphicBuffer();
166 reply.read(**outBuffer);
167 return result;
168 }
169
captureLayers(const sp<IBinder> & layerHandleBinder,sp<GraphicBuffer> * outBuffer,const ui::Dataspace reqDataspace,const ui::PixelFormat reqPixelFormat,const Rect & sourceCrop,const std::unordered_set<sp<IBinder>,SpHash<IBinder>> & excludeLayers,float frameScale,bool childrenOnly)170 virtual status_t captureLayers(
171 const sp<IBinder>& layerHandleBinder, sp<GraphicBuffer>* outBuffer,
172 const ui::Dataspace reqDataspace, const ui::PixelFormat reqPixelFormat,
173 const Rect& sourceCrop,
174 const std::unordered_set<sp<IBinder>, SpHash<IBinder>>& excludeLayers, float frameScale,
175 bool childrenOnly) {
176 Parcel data, reply;
177 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
178 data.writeStrongBinder(layerHandleBinder);
179 data.writeInt32(static_cast<int32_t>(reqDataspace));
180 data.writeInt32(static_cast<int32_t>(reqPixelFormat));
181 data.write(sourceCrop);
182 data.writeInt32(excludeLayers.size());
183 for (auto el : excludeLayers) {
184 data.writeStrongBinder(el);
185 }
186 data.writeFloat(frameScale);
187 data.writeBool(childrenOnly);
188 status_t result = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);
189 if (result != NO_ERROR) {
190 ALOGE("captureLayers failed to transact: %d", result);
191 return result;
192 }
193 result = reply.readInt32();
194 if (result != NO_ERROR) {
195 ALOGE("captureLayers failed to readInt32: %d", result);
196 return result;
197 }
198
199 *outBuffer = new GraphicBuffer();
200 reply.read(**outBuffer);
201
202 return result;
203 }
204
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> & bufferProducer) const205 virtual bool authenticateSurfaceTexture(
206 const sp<IGraphicBufferProducer>& bufferProducer) const
207 {
208 Parcel data, reply;
209 int err = NO_ERROR;
210 err = data.writeInterfaceToken(
211 ISurfaceComposer::getInterfaceDescriptor());
212 if (err != NO_ERROR) {
213 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "
214 "interface descriptor: %s (%d)", strerror(-err), -err);
215 return false;
216 }
217 err = data.writeStrongBinder(IInterface::asBinder(bufferProducer));
218 if (err != NO_ERROR) {
219 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing "
220 "strong binder to parcel: %s (%d)", strerror(-err), -err);
221 return false;
222 }
223 err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data,
224 &reply);
225 if (err != NO_ERROR) {
226 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "
227 "performing transaction: %s (%d)", strerror(-err), -err);
228 return false;
229 }
230 int32_t result = 0;
231 err = reply.readInt32(&result);
232 if (err != NO_ERROR) {
233 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error "
234 "retrieving result: %s (%d)", strerror(-err), -err);
235 return false;
236 }
237 return result != 0;
238 }
239
getSupportedFrameTimestamps(std::vector<FrameEvent> * outSupported) const240 virtual status_t getSupportedFrameTimestamps(
241 std::vector<FrameEvent>* outSupported) const {
242 if (!outSupported) {
243 return UNEXPECTED_NULL;
244 }
245 outSupported->clear();
246
247 Parcel data, reply;
248
249 status_t err = data.writeInterfaceToken(
250 ISurfaceComposer::getInterfaceDescriptor());
251 if (err != NO_ERROR) {
252 return err;
253 }
254
255 err = remote()->transact(
256 BnSurfaceComposer::GET_SUPPORTED_FRAME_TIMESTAMPS,
257 data, &reply);
258 if (err != NO_ERROR) {
259 return err;
260 }
261
262 int32_t result = 0;
263 err = reply.readInt32(&result);
264 if (err != NO_ERROR) {
265 return err;
266 }
267 if (result != NO_ERROR) {
268 return result;
269 }
270
271 std::vector<int32_t> supported;
272 err = reply.readInt32Vector(&supported);
273 if (err != NO_ERROR) {
274 return err;
275 }
276
277 outSupported->reserve(supported.size());
278 for (int32_t s : supported) {
279 outSupported->push_back(static_cast<FrameEvent>(s));
280 }
281 return NO_ERROR;
282 }
283
createDisplayEventConnection(VsyncSource vsyncSource,ConfigChanged configChanged)284 virtual sp<IDisplayEventConnection> createDisplayEventConnection(VsyncSource vsyncSource,
285 ConfigChanged configChanged) {
286 Parcel data, reply;
287 sp<IDisplayEventConnection> result;
288 int err = data.writeInterfaceToken(
289 ISurfaceComposer::getInterfaceDescriptor());
290 if (err != NO_ERROR) {
291 return result;
292 }
293 data.writeInt32(static_cast<int32_t>(vsyncSource));
294 data.writeInt32(static_cast<int32_t>(configChanged));
295 err = remote()->transact(
296 BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION,
297 data, &reply);
298 if (err != NO_ERROR) {
299 ALOGE("ISurfaceComposer::createDisplayEventConnection: error performing "
300 "transaction: %s (%d)", strerror(-err), -err);
301 return result;
302 }
303 result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder());
304 return result;
305 }
306
createDisplay(const String8 & displayName,bool secure)307 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure)
308 {
309 Parcel data, reply;
310 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
311 data.writeString8(displayName);
312 data.writeInt32(secure ? 1 : 0);
313 remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply);
314 return reply.readStrongBinder();
315 }
316
destroyDisplay(const sp<IBinder> & display)317 virtual void destroyDisplay(const sp<IBinder>& display)
318 {
319 Parcel data, reply;
320 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
321 data.writeStrongBinder(display);
322 remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply);
323 }
324
getPhysicalDisplayIds() const325 virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const {
326 Parcel data, reply;
327 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
328 if (remote()->transact(BnSurfaceComposer::GET_PHYSICAL_DISPLAY_IDS, data, &reply) ==
329 NO_ERROR) {
330 std::vector<PhysicalDisplayId> displayIds;
331 if (reply.readUint64Vector(&displayIds) == NO_ERROR) {
332 return displayIds;
333 }
334 }
335
336 return {};
337 }
338
getPhysicalDisplayToken(PhysicalDisplayId displayId) const339 virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
340 Parcel data, reply;
341 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
342 data.writeUint64(displayId);
343 remote()->transact(BnSurfaceComposer::GET_PHYSICAL_DISPLAY_TOKEN, data, &reply);
344 return reply.readStrongBinder();
345 }
346
setPowerMode(const sp<IBinder> & display,int mode)347 virtual void setPowerMode(const sp<IBinder>& display, int mode)
348 {
349 Parcel data, reply;
350 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
351 data.writeStrongBinder(display);
352 data.writeInt32(mode);
353 remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply);
354 }
355
getDisplayState(const sp<IBinder> & display,ui::DisplayState * state)356 virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) {
357 Parcel data, reply;
358 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
359 data.writeStrongBinder(display);
360 remote()->transact(BnSurfaceComposer::GET_DISPLAY_STATE, data, &reply);
361 const status_t result = reply.readInt32();
362 if (result == NO_ERROR) {
363 memcpy(state, reply.readInplace(sizeof(ui::DisplayState)), sizeof(ui::DisplayState));
364 }
365 return result;
366 }
367
getDisplayInfo(const sp<IBinder> & display,DisplayInfo * info)368 virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) {
369 Parcel data, reply;
370 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
371 data.writeStrongBinder(display);
372 remote()->transact(BnSurfaceComposer::GET_DISPLAY_INFO, data, &reply);
373 const status_t result = reply.readInt32();
374 if (result == NO_ERROR) {
375 memcpy(info, reply.readInplace(sizeof(DisplayInfo)), sizeof(DisplayInfo));
376 }
377 return result;
378 }
379
getDisplayConfigs(const sp<IBinder> & display,Vector<DisplayConfig> * configs)380 virtual status_t getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayConfig>* configs) {
381 Parcel data, reply;
382 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
383 data.writeStrongBinder(display);
384 remote()->transact(BnSurfaceComposer::GET_DISPLAY_CONFIGS, data, &reply);
385 const status_t result = reply.readInt32();
386 if (result == NO_ERROR) {
387 const size_t numConfigs = reply.readUint32();
388 configs->clear();
389 configs->resize(numConfigs);
390 for (size_t c = 0; c < numConfigs; ++c) {
391 memcpy(&(configs->editItemAt(c)), reply.readInplace(sizeof(DisplayConfig)),
392 sizeof(DisplayConfig));
393 }
394 }
395 return result;
396 }
397
getDisplayStats(const sp<IBinder> & display,DisplayStatInfo * stats)398 virtual status_t getDisplayStats(const sp<IBinder>& display,
399 DisplayStatInfo* stats)
400 {
401 Parcel data, reply;
402 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
403 data.writeStrongBinder(display);
404 remote()->transact(BnSurfaceComposer::GET_DISPLAY_STATS, data, &reply);
405 status_t result = reply.readInt32();
406 if (result == NO_ERROR) {
407 memcpy(stats,
408 reply.readInplace(sizeof(DisplayStatInfo)),
409 sizeof(DisplayStatInfo));
410 }
411 return result;
412 }
413
getActiveConfig(const sp<IBinder> & display)414 virtual int getActiveConfig(const sp<IBinder>& display)
415 {
416 Parcel data, reply;
417 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
418 data.writeStrongBinder(display);
419 remote()->transact(BnSurfaceComposer::GET_ACTIVE_CONFIG, data, &reply);
420 return reply.readInt32();
421 }
422
getDisplayColorModes(const sp<IBinder> & display,Vector<ColorMode> * outColorModes)423 virtual status_t getDisplayColorModes(const sp<IBinder>& display,
424 Vector<ColorMode>* outColorModes) {
425 Parcel data, reply;
426 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
427 if (result != NO_ERROR) {
428 ALOGE("getDisplayColorModes failed to writeInterfaceToken: %d", result);
429 return result;
430 }
431 result = data.writeStrongBinder(display);
432 if (result != NO_ERROR) {
433 ALOGE("getDisplayColorModes failed to writeStrongBinder: %d", result);
434 return result;
435 }
436 result = remote()->transact(BnSurfaceComposer::GET_DISPLAY_COLOR_MODES, data, &reply);
437 if (result != NO_ERROR) {
438 ALOGE("getDisplayColorModes failed to transact: %d", result);
439 return result;
440 }
441 result = static_cast<status_t>(reply.readInt32());
442 if (result == NO_ERROR) {
443 size_t numModes = reply.readUint32();
444 outColorModes->clear();
445 outColorModes->resize(numModes);
446 for (size_t i = 0; i < numModes; ++i) {
447 outColorModes->replaceAt(static_cast<ColorMode>(reply.readInt32()), i);
448 }
449 }
450 return result;
451 }
452
getDisplayNativePrimaries(const sp<IBinder> & display,ui::DisplayPrimaries & primaries)453 virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display,
454 ui::DisplayPrimaries& primaries) {
455 Parcel data, reply;
456 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
457 if (result != NO_ERROR) {
458 ALOGE("getDisplayNativePrimaries failed to writeInterfaceToken: %d", result);
459 return result;
460 }
461 result = data.writeStrongBinder(display);
462 if (result != NO_ERROR) {
463 ALOGE("getDisplayNativePrimaries failed to writeStrongBinder: %d", result);
464 return result;
465 }
466 result = remote()->transact(BnSurfaceComposer::GET_DISPLAY_NATIVE_PRIMARIES, data, &reply);
467 if (result != NO_ERROR) {
468 ALOGE("getDisplayNativePrimaries failed to transact: %d", result);
469 return result;
470 }
471 result = reply.readInt32();
472 if (result == NO_ERROR) {
473 memcpy(&primaries, reply.readInplace(sizeof(ui::DisplayPrimaries)),
474 sizeof(ui::DisplayPrimaries));
475 }
476 return result;
477 }
478
getActiveColorMode(const sp<IBinder> & display)479 virtual ColorMode getActiveColorMode(const sp<IBinder>& display) {
480 Parcel data, reply;
481 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
482 if (result != NO_ERROR) {
483 ALOGE("getActiveColorMode failed to writeInterfaceToken: %d", result);
484 return static_cast<ColorMode>(result);
485 }
486 result = data.writeStrongBinder(display);
487 if (result != NO_ERROR) {
488 ALOGE("getActiveColorMode failed to writeStrongBinder: %d", result);
489 return static_cast<ColorMode>(result);
490 }
491 result = remote()->transact(BnSurfaceComposer::GET_ACTIVE_COLOR_MODE, data, &reply);
492 if (result != NO_ERROR) {
493 ALOGE("getActiveColorMode failed to transact: %d", result);
494 return static_cast<ColorMode>(result);
495 }
496 return static_cast<ColorMode>(reply.readInt32());
497 }
498
setActiveColorMode(const sp<IBinder> & display,ColorMode colorMode)499 virtual status_t setActiveColorMode(const sp<IBinder>& display,
500 ColorMode colorMode) {
501 Parcel data, reply;
502 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
503 if (result != NO_ERROR) {
504 ALOGE("setActiveColorMode failed to writeInterfaceToken: %d", result);
505 return result;
506 }
507 result = data.writeStrongBinder(display);
508 if (result != NO_ERROR) {
509 ALOGE("setActiveColorMode failed to writeStrongBinder: %d", result);
510 return result;
511 }
512 result = data.writeInt32(static_cast<int32_t>(colorMode));
513 if (result != NO_ERROR) {
514 ALOGE("setActiveColorMode failed to writeInt32: %d", result);
515 return result;
516 }
517 result = remote()->transact(BnSurfaceComposer::SET_ACTIVE_COLOR_MODE, data, &reply);
518 if (result != NO_ERROR) {
519 ALOGE("setActiveColorMode failed to transact: %d", result);
520 return result;
521 }
522 return static_cast<status_t>(reply.readInt32());
523 }
524
getAutoLowLatencyModeSupport(const sp<IBinder> & display,bool * outSupport) const525 virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,
526 bool* outSupport) const {
527 Parcel data, reply;
528 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
529 status_t result = data.writeStrongBinder(display);
530 if (result != NO_ERROR) {
531 ALOGE("getAutoLowLatencyModeSupport failed to writeStrongBinder: %d", result);
532 return result;
533 }
534 result = remote()->transact(BnSurfaceComposer::GET_AUTO_LOW_LATENCY_MODE_SUPPORT, data,
535 &reply);
536 if (result != NO_ERROR) {
537 ALOGE("getAutoLowLatencyModeSupport failed to transact: %d", result);
538 return result;
539 }
540 return reply.readBool(outSupport);
541 }
542
setAutoLowLatencyMode(const sp<IBinder> & display,bool on)543 virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
544 Parcel data, reply;
545 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
546 if (result != NO_ERROR) {
547 ALOGE("setAutoLowLatencyMode failed to writeInterfaceToken: %d", result);
548 return;
549 }
550
551 result = data.writeStrongBinder(display);
552 if (result != NO_ERROR) {
553 ALOGE("setAutoLowLatencyMode failed to writeStrongBinder: %d", result);
554 return;
555 }
556 result = data.writeBool(on);
557 if (result != NO_ERROR) {
558 ALOGE("setAutoLowLatencyMode failed to writeBool: %d", result);
559 return;
560 }
561 result = remote()->transact(BnSurfaceComposer::SET_AUTO_LOW_LATENCY_MODE, data, &reply);
562 if (result != NO_ERROR) {
563 ALOGE("setAutoLowLatencyMode failed to transact: %d", result);
564 return;
565 }
566 }
567
getGameContentTypeSupport(const sp<IBinder> & display,bool * outSupport) const568 virtual status_t getGameContentTypeSupport(const sp<IBinder>& display, bool* outSupport) const {
569 Parcel data, reply;
570 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
571 status_t result = data.writeStrongBinder(display);
572 if (result != NO_ERROR) {
573 ALOGE("getGameContentTypeSupport failed to writeStrongBinder: %d", result);
574 return result;
575 }
576 result = remote()->transact(BnSurfaceComposer::GET_GAME_CONTENT_TYPE_SUPPORT, data, &reply);
577 if (result != NO_ERROR) {
578 ALOGE("getGameContentTypeSupport failed to transact: %d", result);
579 return result;
580 }
581 return reply.readBool(outSupport);
582 }
583
setGameContentType(const sp<IBinder> & display,bool on)584 virtual void setGameContentType(const sp<IBinder>& display, bool on) {
585 Parcel data, reply;
586 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
587 if (result != NO_ERROR) {
588 ALOGE("setGameContentType failed to writeInterfaceToken: %d", result);
589 return;
590 }
591 result = data.writeStrongBinder(display);
592 if (result != NO_ERROR) {
593 ALOGE("setGameContentType failed to writeStrongBinder: %d", result);
594 return;
595 }
596 result = data.writeBool(on);
597 if (result != NO_ERROR) {
598 ALOGE("setGameContentType failed to writeBool: %d", result);
599 return;
600 }
601 result = remote()->transact(BnSurfaceComposer::SET_GAME_CONTENT_TYPE, data, &reply);
602 if (result != NO_ERROR) {
603 ALOGE("setGameContentType failed to transact: %d", result);
604 }
605 }
606
clearAnimationFrameStats()607 virtual status_t clearAnimationFrameStats() {
608 Parcel data, reply;
609 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
610 if (result != NO_ERROR) {
611 ALOGE("clearAnimationFrameStats failed to writeInterfaceToken: %d", result);
612 return result;
613 }
614 result = remote()->transact(BnSurfaceComposer::CLEAR_ANIMATION_FRAME_STATS, data, &reply);
615 if (result != NO_ERROR) {
616 ALOGE("clearAnimationFrameStats failed to transact: %d", result);
617 return result;
618 }
619 return reply.readInt32();
620 }
621
getAnimationFrameStats(FrameStats * outStats) const622 virtual status_t getAnimationFrameStats(FrameStats* outStats) const {
623 Parcel data, reply;
624 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
625 remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply);
626 reply.read(*outStats);
627 return reply.readInt32();
628 }
629
getHdrCapabilities(const sp<IBinder> & display,HdrCapabilities * outCapabilities) const630 virtual status_t getHdrCapabilities(const sp<IBinder>& display,
631 HdrCapabilities* outCapabilities) const {
632 Parcel data, reply;
633 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
634 status_t result = data.writeStrongBinder(display);
635 if (result != NO_ERROR) {
636 ALOGE("getHdrCapabilities failed to writeStrongBinder: %d", result);
637 return result;
638 }
639 result = remote()->transact(BnSurfaceComposer::GET_HDR_CAPABILITIES,
640 data, &reply);
641 if (result != NO_ERROR) {
642 ALOGE("getHdrCapabilities failed to transact: %d", result);
643 return result;
644 }
645 result = reply.readInt32();
646 if (result == NO_ERROR) {
647 result = reply.read(*outCapabilities);
648 }
649 return result;
650 }
651
enableVSyncInjections(bool enable)652 virtual status_t enableVSyncInjections(bool enable) {
653 Parcel data, reply;
654 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
655 if (result != NO_ERROR) {
656 ALOGE("enableVSyncInjections failed to writeInterfaceToken: %d", result);
657 return result;
658 }
659 result = data.writeBool(enable);
660 if (result != NO_ERROR) {
661 ALOGE("enableVSyncInjections failed to writeBool: %d", result);
662 return result;
663 }
664 result = remote()->transact(BnSurfaceComposer::ENABLE_VSYNC_INJECTIONS, data, &reply,
665 IBinder::FLAG_ONEWAY);
666 if (result != NO_ERROR) {
667 ALOGE("enableVSyncInjections failed to transact: %d", result);
668 return result;
669 }
670 return result;
671 }
672
injectVSync(nsecs_t when)673 virtual status_t injectVSync(nsecs_t when) {
674 Parcel data, reply;
675 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
676 if (result != NO_ERROR) {
677 ALOGE("injectVSync failed to writeInterfaceToken: %d", result);
678 return result;
679 }
680 result = data.writeInt64(when);
681 if (result != NO_ERROR) {
682 ALOGE("injectVSync failed to writeInt64: %d", result);
683 return result;
684 }
685 result = remote()->transact(BnSurfaceComposer::INJECT_VSYNC, data, &reply,
686 IBinder::FLAG_ONEWAY);
687 if (result != NO_ERROR) {
688 ALOGE("injectVSync failed to transact: %d", result);
689 return result;
690 }
691 return result;
692 }
693
getLayerDebugInfo(std::vector<LayerDebugInfo> * outLayers)694 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) {
695 if (!outLayers) {
696 return UNEXPECTED_NULL;
697 }
698
699 Parcel data, reply;
700
701 status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
702 if (err != NO_ERROR) {
703 return err;
704 }
705
706 err = remote()->transact(BnSurfaceComposer::GET_LAYER_DEBUG_INFO, data, &reply);
707 if (err != NO_ERROR) {
708 return err;
709 }
710
711 int32_t result = 0;
712 err = reply.readInt32(&result);
713 if (err != NO_ERROR) {
714 return err;
715 }
716 if (result != NO_ERROR) {
717 return result;
718 }
719
720 outLayers->clear();
721 return reply.readParcelableVector(outLayers);
722 }
723
getCompositionPreference(ui::Dataspace * defaultDataspace,ui::PixelFormat * defaultPixelFormat,ui::Dataspace * wideColorGamutDataspace,ui::PixelFormat * wideColorGamutPixelFormat) const724 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
725 ui::PixelFormat* defaultPixelFormat,
726 ui::Dataspace* wideColorGamutDataspace,
727 ui::PixelFormat* wideColorGamutPixelFormat) const {
728 Parcel data, reply;
729 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
730 if (error != NO_ERROR) {
731 return error;
732 }
733 error = remote()->transact(BnSurfaceComposer::GET_COMPOSITION_PREFERENCE, data, &reply);
734 if (error != NO_ERROR) {
735 return error;
736 }
737 error = static_cast<status_t>(reply.readInt32());
738 if (error == NO_ERROR) {
739 *defaultDataspace = static_cast<ui::Dataspace>(reply.readInt32());
740 *defaultPixelFormat = static_cast<ui::PixelFormat>(reply.readInt32());
741 *wideColorGamutDataspace = static_cast<ui::Dataspace>(reply.readInt32());
742 *wideColorGamutPixelFormat = static_cast<ui::PixelFormat>(reply.readInt32());
743 }
744 return error;
745 }
746
getColorManagement(bool * outGetColorManagement) const747 virtual status_t getColorManagement(bool* outGetColorManagement) const {
748 Parcel data, reply;
749 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
750 remote()->transact(BnSurfaceComposer::GET_COLOR_MANAGEMENT, data, &reply);
751 bool result;
752 status_t err = reply.readBool(&result);
753 if (err == NO_ERROR) {
754 *outGetColorManagement = result;
755 }
756 return err;
757 }
758
getDisplayedContentSamplingAttributes(const sp<IBinder> & display,ui::PixelFormat * outFormat,ui::Dataspace * outDataspace,uint8_t * outComponentMask) const759 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
760 ui::PixelFormat* outFormat,
761 ui::Dataspace* outDataspace,
762 uint8_t* outComponentMask) const {
763 if (!outFormat || !outDataspace || !outComponentMask) return BAD_VALUE;
764 Parcel data, reply;
765 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
766 data.writeStrongBinder(display);
767
768 status_t error =
769 remote()->transact(BnSurfaceComposer::GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES,
770 data, &reply);
771 if (error != NO_ERROR) {
772 return error;
773 }
774
775 uint32_t value = 0;
776 error = reply.readUint32(&value);
777 if (error != NO_ERROR) {
778 return error;
779 }
780 *outFormat = static_cast<ui::PixelFormat>(value);
781
782 error = reply.readUint32(&value);
783 if (error != NO_ERROR) {
784 return error;
785 }
786 *outDataspace = static_cast<ui::Dataspace>(value);
787
788 error = reply.readUint32(&value);
789 if (error != NO_ERROR) {
790 return error;
791 }
792 *outComponentMask = static_cast<uint8_t>(value);
793 return error;
794 }
795
setDisplayContentSamplingEnabled(const sp<IBinder> & display,bool enable,uint8_t componentMask,uint64_t maxFrames)796 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
797 uint8_t componentMask, uint64_t maxFrames) {
798 Parcel data, reply;
799 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
800 data.writeStrongBinder(display);
801 data.writeBool(enable);
802 data.writeByte(static_cast<int8_t>(componentMask));
803 data.writeUint64(maxFrames);
804 status_t result =
805 remote()->transact(BnSurfaceComposer::SET_DISPLAY_CONTENT_SAMPLING_ENABLED, data,
806 &reply);
807 return result;
808 }
809
getDisplayedContentSample(const sp<IBinder> & display,uint64_t maxFrames,uint64_t timestamp,DisplayedFrameStats * outStats) const810 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
811 uint64_t timestamp,
812 DisplayedFrameStats* outStats) const {
813 if (!outStats) return BAD_VALUE;
814
815 Parcel data, reply;
816 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
817 data.writeStrongBinder(display);
818 data.writeUint64(maxFrames);
819 data.writeUint64(timestamp);
820
821 status_t result =
822 remote()->transact(BnSurfaceComposer::GET_DISPLAYED_CONTENT_SAMPLE, data, &reply);
823
824 if (result != NO_ERROR) {
825 return result;
826 }
827
828 result = reply.readUint64(&outStats->numFrames);
829 if (result != NO_ERROR) {
830 return result;
831 }
832
833 result = reply.readUint64Vector(&outStats->component_0_sample);
834 if (result != NO_ERROR) {
835 return result;
836 }
837 result = reply.readUint64Vector(&outStats->component_1_sample);
838 if (result != NO_ERROR) {
839 return result;
840 }
841 result = reply.readUint64Vector(&outStats->component_2_sample);
842 if (result != NO_ERROR) {
843 return result;
844 }
845 result = reply.readUint64Vector(&outStats->component_3_sample);
846 return result;
847 }
848
getProtectedContentSupport(bool * outSupported) const849 virtual status_t getProtectedContentSupport(bool* outSupported) const {
850 Parcel data, reply;
851 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
852 status_t error =
853 remote()->transact(BnSurfaceComposer::GET_PROTECTED_CONTENT_SUPPORT, data, &reply);
854 if (error != NO_ERROR) {
855 return error;
856 }
857 error = reply.readBool(outSupported);
858 return error;
859 }
860
isWideColorDisplay(const sp<IBinder> & token,bool * outIsWideColorDisplay) const861 virtual status_t isWideColorDisplay(const sp<IBinder>& token,
862 bool* outIsWideColorDisplay) const {
863 Parcel data, reply;
864 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
865 if (error != NO_ERROR) {
866 return error;
867 }
868 error = data.writeStrongBinder(token);
869 if (error != NO_ERROR) {
870 return error;
871 }
872
873 error = remote()->transact(BnSurfaceComposer::IS_WIDE_COLOR_DISPLAY, data, &reply);
874 if (error != NO_ERROR) {
875 return error;
876 }
877 error = reply.readBool(outIsWideColorDisplay);
878 return error;
879 }
880
addRegionSamplingListener(const Rect & samplingArea,const sp<IBinder> & stopLayerHandle,const sp<IRegionSamplingListener> & listener)881 virtual status_t addRegionSamplingListener(const Rect& samplingArea,
882 const sp<IBinder>& stopLayerHandle,
883 const sp<IRegionSamplingListener>& listener) {
884 Parcel data, reply;
885 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
886 if (error != NO_ERROR) {
887 ALOGE("addRegionSamplingListener: Failed to write interface token");
888 return error;
889 }
890 error = data.write(samplingArea);
891 if (error != NO_ERROR) {
892 ALOGE("addRegionSamplingListener: Failed to write sampling area");
893 return error;
894 }
895 error = data.writeStrongBinder(stopLayerHandle);
896 if (error != NO_ERROR) {
897 ALOGE("addRegionSamplingListener: Failed to write stop layer handle");
898 return error;
899 }
900 error = data.writeStrongBinder(IInterface::asBinder(listener));
901 if (error != NO_ERROR) {
902 ALOGE("addRegionSamplingListener: Failed to write listener");
903 return error;
904 }
905 error = remote()->transact(BnSurfaceComposer::ADD_REGION_SAMPLING_LISTENER, data, &reply);
906 if (error != NO_ERROR) {
907 ALOGE("addRegionSamplingListener: Failed to transact");
908 }
909 return error;
910 }
911
removeRegionSamplingListener(const sp<IRegionSamplingListener> & listener)912 virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
913 Parcel data, reply;
914 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
915 if (error != NO_ERROR) {
916 ALOGE("removeRegionSamplingListener: Failed to write interface token");
917 return error;
918 }
919 error = data.writeStrongBinder(IInterface::asBinder(listener));
920 if (error != NO_ERROR) {
921 ALOGE("removeRegionSamplingListener: Failed to write listener");
922 return error;
923 }
924 error = remote()->transact(BnSurfaceComposer::REMOVE_REGION_SAMPLING_LISTENER, data,
925 &reply);
926 if (error != NO_ERROR) {
927 ALOGE("removeRegionSamplingListener: Failed to transact");
928 }
929 return error;
930 }
931
setDesiredDisplayConfigSpecs(const sp<IBinder> & displayToken,int32_t defaultConfig,float primaryRefreshRateMin,float primaryRefreshRateMax,float appRequestRefreshRateMin,float appRequestRefreshRateMax)932 virtual status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
933 int32_t defaultConfig,
934 float primaryRefreshRateMin,
935 float primaryRefreshRateMax,
936 float appRequestRefreshRateMin,
937 float appRequestRefreshRateMax) {
938 Parcel data, reply;
939 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
940 if (result != NO_ERROR) {
941 ALOGE("setDesiredDisplayConfigSpecs: failed to writeInterfaceToken: %d", result);
942 return result;
943 }
944 result = data.writeStrongBinder(displayToken);
945 if (result != NO_ERROR) {
946 ALOGE("setDesiredDisplayConfigSpecs: failed to write display token: %d", result);
947 return result;
948 }
949 result = data.writeInt32(defaultConfig);
950 if (result != NO_ERROR) {
951 ALOGE("setDesiredDisplayConfigSpecs failed to write defaultConfig: %d", result);
952 return result;
953 }
954 result = data.writeFloat(primaryRefreshRateMin);
955 if (result != NO_ERROR) {
956 ALOGE("setDesiredDisplayConfigSpecs failed to write primaryRefreshRateMin: %d", result);
957 return result;
958 }
959 result = data.writeFloat(primaryRefreshRateMax);
960 if (result != NO_ERROR) {
961 ALOGE("setDesiredDisplayConfigSpecs failed to write primaryRefreshRateMax: %d", result);
962 return result;
963 }
964 result = data.writeFloat(appRequestRefreshRateMin);
965 if (result != NO_ERROR) {
966 ALOGE("setDesiredDisplayConfigSpecs failed to write appRequestRefreshRateMin: %d",
967 result);
968 return result;
969 }
970 result = data.writeFloat(appRequestRefreshRateMax);
971 if (result != NO_ERROR) {
972 ALOGE("setDesiredDisplayConfigSpecs failed to write appRequestRefreshRateMax: %d",
973 result);
974 return result;
975 }
976
977 result = remote()->transact(BnSurfaceComposer::SET_DESIRED_DISPLAY_CONFIG_SPECS, data,
978 &reply);
979 if (result != NO_ERROR) {
980 ALOGE("setDesiredDisplayConfigSpecs failed to transact: %d", result);
981 return result;
982 }
983 return reply.readInt32();
984 }
985
getDesiredDisplayConfigSpecs(const sp<IBinder> & displayToken,int32_t * outDefaultConfig,float * outPrimaryRefreshRateMin,float * outPrimaryRefreshRateMax,float * outAppRequestRefreshRateMin,float * outAppRequestRefreshRateMax)986 virtual status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
987 int32_t* outDefaultConfig,
988 float* outPrimaryRefreshRateMin,
989 float* outPrimaryRefreshRateMax,
990 float* outAppRequestRefreshRateMin,
991 float* outAppRequestRefreshRateMax) {
992 if (!outDefaultConfig || !outPrimaryRefreshRateMin || !outPrimaryRefreshRateMax ||
993 !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
994 return BAD_VALUE;
995 }
996 Parcel data, reply;
997 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
998 if (result != NO_ERROR) {
999 ALOGE("getDesiredDisplayConfigSpecs failed to writeInterfaceToken: %d", result);
1000 return result;
1001 }
1002 result = data.writeStrongBinder(displayToken);
1003 if (result != NO_ERROR) {
1004 ALOGE("getDesiredDisplayConfigSpecs failed to writeStrongBinder: %d", result);
1005 return result;
1006 }
1007 result = remote()->transact(BnSurfaceComposer::GET_DESIRED_DISPLAY_CONFIG_SPECS, data,
1008 &reply);
1009 if (result != NO_ERROR) {
1010 ALOGE("getDesiredDisplayConfigSpecs failed to transact: %d", result);
1011 return result;
1012 }
1013 result = reply.readInt32(outDefaultConfig);
1014 if (result != NO_ERROR) {
1015 ALOGE("getDesiredDisplayConfigSpecs failed to read defaultConfig: %d", result);
1016 return result;
1017 }
1018 result = reply.readFloat(outPrimaryRefreshRateMin);
1019 if (result != NO_ERROR) {
1020 ALOGE("getDesiredDisplayConfigSpecs failed to read primaryRefreshRateMin: %d", result);
1021 return result;
1022 }
1023 result = reply.readFloat(outPrimaryRefreshRateMax);
1024 if (result != NO_ERROR) {
1025 ALOGE("getDesiredDisplayConfigSpecs failed to read primaryRefreshRateMax: %d", result);
1026 return result;
1027 }
1028 result = reply.readFloat(outAppRequestRefreshRateMin);
1029 if (result != NO_ERROR) {
1030 ALOGE("getDesiredDisplayConfigSpecs failed to read appRequestRefreshRateMin: %d",
1031 result);
1032 return result;
1033 }
1034 result = reply.readFloat(outAppRequestRefreshRateMax);
1035 if (result != NO_ERROR) {
1036 ALOGE("getDesiredDisplayConfigSpecs failed to read appRequestRefreshRateMax: %d",
1037 result);
1038 return result;
1039 }
1040 return reply.readInt32();
1041 }
1042
getDisplayBrightnessSupport(const sp<IBinder> & displayToken,bool * outSupport) const1043 virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
1044 bool* outSupport) const {
1045 Parcel data, reply;
1046 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1047 if (error != NO_ERROR) {
1048 ALOGE("getDisplayBrightnessSupport: failed to write interface token: %d", error);
1049 return error;
1050 }
1051 error = data.writeStrongBinder(displayToken);
1052 if (error != NO_ERROR) {
1053 ALOGE("getDisplayBrightnessSupport: failed to write display token: %d", error);
1054 return error;
1055 }
1056 error = remote()->transact(BnSurfaceComposer::GET_DISPLAY_BRIGHTNESS_SUPPORT, data, &reply);
1057 if (error != NO_ERROR) {
1058 ALOGE("getDisplayBrightnessSupport: failed to transact: %d", error);
1059 return error;
1060 }
1061 bool support;
1062 error = reply.readBool(&support);
1063 if (error != NO_ERROR) {
1064 ALOGE("getDisplayBrightnessSupport: failed to read support: %d", error);
1065 return error;
1066 }
1067 *outSupport = support;
1068 return NO_ERROR;
1069 }
1070
setDisplayBrightness(const sp<IBinder> & displayToken,float brightness)1071 virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) {
1072 Parcel data, reply;
1073 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1074 if (error != NO_ERROR) {
1075 ALOGE("setDisplayBrightness: failed to write interface token: %d", error);
1076 return error;
1077 }
1078 error = data.writeStrongBinder(displayToken);
1079 if (error != NO_ERROR) {
1080 ALOGE("setDisplayBrightness: failed to write display token: %d", error);
1081 return error;
1082 }
1083 error = data.writeFloat(brightness);
1084 if (error != NO_ERROR) {
1085 ALOGE("setDisplayBrightness: failed to write brightness: %d", error);
1086 return error;
1087 }
1088 error = remote()->transact(BnSurfaceComposer::SET_DISPLAY_BRIGHTNESS, data, &reply);
1089 if (error != NO_ERROR) {
1090 ALOGE("setDisplayBrightness: failed to transact: %d", error);
1091 return error;
1092 }
1093 return NO_ERROR;
1094 }
1095
notifyPowerHint(int32_t hintId)1096 virtual status_t notifyPowerHint(int32_t hintId) {
1097 Parcel data, reply;
1098 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1099 if (error != NO_ERROR) {
1100 ALOGE("notifyPowerHint: failed to write interface token: %d", error);
1101 return error;
1102 }
1103 error = data.writeInt32(hintId);
1104 if (error != NO_ERROR) {
1105 ALOGE("notifyPowerHint: failed to write hintId: %d", error);
1106 return error;
1107 }
1108 error = remote()->transact(BnSurfaceComposer::NOTIFY_POWER_HINT, data, &reply,
1109 IBinder::FLAG_ONEWAY);
1110 if (error != NO_ERROR) {
1111 ALOGE("notifyPowerHint: failed to transact: %d", error);
1112 return error;
1113 }
1114 return NO_ERROR;
1115 }
1116
setGlobalShadowSettings(const half4 & ambientColor,const half4 & spotColor,float lightPosY,float lightPosZ,float lightRadius)1117 virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
1118 float lightPosY, float lightPosZ, float lightRadius) {
1119 Parcel data, reply;
1120 status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1121 if (error != NO_ERROR) {
1122 ALOGE("setGlobalShadowSettings: failed to write interface token: %d", error);
1123 return error;
1124 }
1125
1126 std::vector<float> shadowConfig = {ambientColor.r, ambientColor.g, ambientColor.b,
1127 ambientColor.a, spotColor.r, spotColor.g,
1128 spotColor.b, spotColor.a, lightPosY,
1129 lightPosZ, lightRadius};
1130
1131 error = data.writeFloatVector(shadowConfig);
1132 if (error != NO_ERROR) {
1133 ALOGE("setGlobalShadowSettings: failed to write shadowConfig: %d", error);
1134 return error;
1135 }
1136
1137 error = remote()->transact(BnSurfaceComposer::SET_GLOBAL_SHADOW_SETTINGS, data, &reply,
1138 IBinder::FLAG_ONEWAY);
1139 if (error != NO_ERROR) {
1140 ALOGE("setGlobalShadowSettings: failed to transact: %d", error);
1141 return error;
1142 }
1143 return NO_ERROR;
1144 }
1145
setFrameRate(const sp<IGraphicBufferProducer> & surface,float frameRate,int8_t compatibility)1146 virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
1147 int8_t compatibility) {
1148 Parcel data, reply;
1149 status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1150 if (err != NO_ERROR) {
1151 ALOGE("setFrameRate: failed writing interface token: %s (%d)", strerror(-err), -err);
1152 return err;
1153 }
1154
1155 err = data.writeStrongBinder(IInterface::asBinder(surface));
1156 if (err != NO_ERROR) {
1157 ALOGE("setFrameRate: failed writing strong binder: %s (%d)", strerror(-err), -err);
1158 return err;
1159 }
1160
1161 err = data.writeFloat(frameRate);
1162 if (err != NO_ERROR) {
1163 ALOGE("setFrameRate: failed writing float: %s (%d)", strerror(-err), -err);
1164 return err;
1165 }
1166
1167 err = data.writeByte(compatibility);
1168 if (err != NO_ERROR) {
1169 ALOGE("setFrameRate: failed writing byte: %s (%d)", strerror(-err), -err);
1170 return err;
1171 }
1172
1173 err = remote()->transact(BnSurfaceComposer::SET_FRAME_RATE, data, &reply);
1174 if (err != NO_ERROR) {
1175 ALOGE("setFrameRate: failed to transact: %s (%d)", strerror(-err), err);
1176 return err;
1177 }
1178
1179 return reply.readInt32();
1180 }
1181
acquireFrameRateFlexibilityToken(sp<IBinder> * outToken)1182 virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
1183 if (!outToken) return BAD_VALUE;
1184
1185 Parcel data, reply;
1186 status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
1187 if (err != NO_ERROR) {
1188 ALOGE("acquireFrameRateFlexibilityToken: failed writing interface token: %s (%d)",
1189 strerror(-err), -err);
1190 return err;
1191 }
1192
1193 err = remote()->transact(BnSurfaceComposer::ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN, data,
1194 &reply);
1195 if (err != NO_ERROR) {
1196 ALOGE("acquireFrameRateFlexibilityToken: failed to transact: %s (%d)", strerror(-err),
1197 err);
1198 return err;
1199 }
1200
1201 err = reply.readInt32();
1202 if (err != NO_ERROR) {
1203 ALOGE("acquireFrameRateFlexibilityToken: call failed: %s (%d)", strerror(-err), err);
1204 return err;
1205 }
1206
1207 err = reply.readStrongBinder(outToken);
1208 if (err != NO_ERROR) {
1209 ALOGE("acquireFrameRateFlexibilityToken: failed reading binder token: %s (%d)",
1210 strerror(-err), err);
1211 return err;
1212 }
1213
1214 return NO_ERROR;
1215 }
1216 };
1217
1218 // Out-of-line virtual method definition to trigger vtable emission in this
1219 // translation unit (see clang warning -Wweak-vtables)
~BpSurfaceComposer()1220 BpSurfaceComposer::~BpSurfaceComposer() {}
1221
1222 IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer");
1223
1224 // ----------------------------------------------------------------------
1225
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)1226 status_t BnSurfaceComposer::onTransact(
1227 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
1228 {
1229 switch(code) {
1230 case CREATE_CONNECTION: {
1231 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1232 sp<IBinder> b = IInterface::asBinder(createConnection());
1233 reply->writeStrongBinder(b);
1234 return NO_ERROR;
1235 }
1236 case SET_TRANSACTION_STATE: {
1237 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1238
1239 size_t count = data.readUint32();
1240 if (count > data.dataSize()) {
1241 return BAD_VALUE;
1242 }
1243 Vector<ComposerState> state;
1244 state.setCapacity(count);
1245 for (size_t i = 0; i < count; i++) {
1246 ComposerState s;
1247 if (s.read(data) == BAD_VALUE) {
1248 return BAD_VALUE;
1249 }
1250 state.add(s);
1251 }
1252
1253 count = data.readUint32();
1254 if (count > data.dataSize()) {
1255 return BAD_VALUE;
1256 }
1257 DisplayState d;
1258 Vector<DisplayState> displays;
1259 displays.setCapacity(count);
1260 for (size_t i = 0; i < count; i++) {
1261 if (d.read(data) == BAD_VALUE) {
1262 return BAD_VALUE;
1263 }
1264 displays.add(d);
1265 }
1266
1267 uint32_t stateFlags = data.readUint32();
1268 sp<IBinder> applyToken = data.readStrongBinder();
1269 InputWindowCommands inputWindowCommands;
1270 inputWindowCommands.read(data);
1271
1272 int64_t desiredPresentTime = data.readInt64();
1273
1274 client_cache_t uncachedBuffer;
1275 uncachedBuffer.token = data.readStrongBinder();
1276 uncachedBuffer.id = data.readUint64();
1277
1278 bool hasListenerCallbacks = data.readBool();
1279
1280 std::vector<ListenerCallbacks> listenerCallbacks;
1281 int32_t listenersSize = data.readInt32();
1282 for (int32_t i = 0; i < listenersSize; i++) {
1283 auto listener = data.readStrongBinder();
1284 std::vector<CallbackId> callbackIds;
1285 data.readInt64Vector(&callbackIds);
1286 listenerCallbacks.emplace_back(listener, callbackIds);
1287 }
1288 setTransactionState(state, displays, stateFlags, applyToken, inputWindowCommands,
1289 desiredPresentTime, uncachedBuffer, hasListenerCallbacks,
1290 listenerCallbacks);
1291 return NO_ERROR;
1292 }
1293 case BOOT_FINISHED: {
1294 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1295 bootFinished();
1296 return NO_ERROR;
1297 }
1298 case CAPTURE_SCREEN: {
1299 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1300 sp<IBinder> display = data.readStrongBinder();
1301 ui::Dataspace reqDataspace = static_cast<ui::Dataspace>(data.readInt32());
1302 ui::PixelFormat reqPixelFormat = static_cast<ui::PixelFormat>(data.readInt32());
1303 sp<GraphicBuffer> outBuffer;
1304 Rect sourceCrop(Rect::EMPTY_RECT);
1305 data.read(sourceCrop);
1306 uint32_t reqWidth = data.readUint32();
1307 uint32_t reqHeight = data.readUint32();
1308 bool useIdentityTransform = static_cast<bool>(data.readInt32());
1309 int32_t rotation = data.readInt32();
1310 bool captureSecureLayers = static_cast<bool>(data.readInt32());
1311
1312 bool capturedSecureLayers = false;
1313 status_t res = captureScreen(display, &outBuffer, capturedSecureLayers, reqDataspace,
1314 reqPixelFormat, sourceCrop, reqWidth, reqHeight,
1315 useIdentityTransform, ui::toRotation(rotation),
1316 captureSecureLayers);
1317
1318 reply->writeInt32(res);
1319 if (res == NO_ERROR) {
1320 reply->write(*outBuffer);
1321 reply->writeBool(capturedSecureLayers);
1322 }
1323 return NO_ERROR;
1324 }
1325 case CAPTURE_SCREEN_BY_ID: {
1326 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1327 uint64_t displayOrLayerStack = data.readUint64();
1328 ui::Dataspace outDataspace = ui::Dataspace::V0_SRGB;
1329 sp<GraphicBuffer> outBuffer;
1330 status_t res = captureScreen(displayOrLayerStack, &outDataspace, &outBuffer);
1331 reply->writeInt32(res);
1332 if (res == NO_ERROR) {
1333 reply->writeInt32(static_cast<int32_t>(outDataspace));
1334 reply->write(*outBuffer);
1335 }
1336 return NO_ERROR;
1337 }
1338 case CAPTURE_LAYERS: {
1339 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1340 sp<IBinder> layerHandleBinder = data.readStrongBinder();
1341 ui::Dataspace reqDataspace = static_cast<ui::Dataspace>(data.readInt32());
1342 ui::PixelFormat reqPixelFormat = static_cast<ui::PixelFormat>(data.readInt32());
1343 sp<GraphicBuffer> outBuffer;
1344 Rect sourceCrop(Rect::EMPTY_RECT);
1345 data.read(sourceCrop);
1346
1347 std::unordered_set<sp<IBinder>, SpHash<IBinder>> excludeHandles;
1348 int numExcludeHandles = data.readInt32();
1349 if (numExcludeHandles >= static_cast<int>(MAX_LAYERS)) {
1350 return BAD_VALUE;
1351 }
1352 excludeHandles.reserve(numExcludeHandles);
1353 for (int i = 0; i < numExcludeHandles; i++) {
1354 excludeHandles.emplace(data.readStrongBinder());
1355 }
1356
1357 float frameScale = data.readFloat();
1358 bool childrenOnly = data.readBool();
1359
1360 status_t res =
1361 captureLayers(layerHandleBinder, &outBuffer, reqDataspace, reqPixelFormat,
1362 sourceCrop, excludeHandles, frameScale, childrenOnly);
1363 reply->writeInt32(res);
1364 if (res == NO_ERROR) {
1365 reply->write(*outBuffer);
1366 }
1367 return NO_ERROR;
1368 }
1369 case AUTHENTICATE_SURFACE: {
1370 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1371 sp<IGraphicBufferProducer> bufferProducer =
1372 interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
1373 int32_t result = authenticateSurfaceTexture(bufferProducer) ? 1 : 0;
1374 reply->writeInt32(result);
1375 return NO_ERROR;
1376 }
1377 case GET_SUPPORTED_FRAME_TIMESTAMPS: {
1378 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1379 std::vector<FrameEvent> supportedTimestamps;
1380 status_t result = getSupportedFrameTimestamps(&supportedTimestamps);
1381 status_t err = reply->writeInt32(result);
1382 if (err != NO_ERROR) {
1383 return err;
1384 }
1385 if (result != NO_ERROR) {
1386 return result;
1387 }
1388
1389 std::vector<int32_t> supported;
1390 supported.reserve(supportedTimestamps.size());
1391 for (FrameEvent s : supportedTimestamps) {
1392 supported.push_back(static_cast<int32_t>(s));
1393 }
1394 return reply->writeInt32Vector(supported);
1395 }
1396 case CREATE_DISPLAY_EVENT_CONNECTION: {
1397 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1398 auto vsyncSource = static_cast<ISurfaceComposer::VsyncSource>(data.readInt32());
1399 auto configChanged = static_cast<ISurfaceComposer::ConfigChanged>(data.readInt32());
1400
1401 sp<IDisplayEventConnection> connection(
1402 createDisplayEventConnection(vsyncSource, configChanged));
1403 reply->writeStrongBinder(IInterface::asBinder(connection));
1404 return NO_ERROR;
1405 }
1406 case CREATE_DISPLAY: {
1407 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1408 String8 displayName = data.readString8();
1409 bool secure = bool(data.readInt32());
1410 sp<IBinder> display(createDisplay(displayName, secure));
1411 reply->writeStrongBinder(display);
1412 return NO_ERROR;
1413 }
1414 case DESTROY_DISPLAY: {
1415 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1416 sp<IBinder> display = data.readStrongBinder();
1417 destroyDisplay(display);
1418 return NO_ERROR;
1419 }
1420 case GET_PHYSICAL_DISPLAY_TOKEN: {
1421 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1422 PhysicalDisplayId displayId = data.readUint64();
1423 sp<IBinder> display = getPhysicalDisplayToken(displayId);
1424 reply->writeStrongBinder(display);
1425 return NO_ERROR;
1426 }
1427 case GET_DISPLAY_STATE: {
1428 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1429 ui::DisplayState state;
1430 const sp<IBinder> display = data.readStrongBinder();
1431 const status_t result = getDisplayState(display, &state);
1432 reply->writeInt32(result);
1433 if (result == NO_ERROR) {
1434 memcpy(reply->writeInplace(sizeof(ui::DisplayState)), &state,
1435 sizeof(ui::DisplayState));
1436 }
1437 return NO_ERROR;
1438 }
1439 case GET_DISPLAY_INFO: {
1440 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1441 DisplayInfo info;
1442 const sp<IBinder> display = data.readStrongBinder();
1443 const status_t result = getDisplayInfo(display, &info);
1444 reply->writeInt32(result);
1445 if (result == NO_ERROR) {
1446 memcpy(reply->writeInplace(sizeof(DisplayInfo)), &info, sizeof(DisplayInfo));
1447 }
1448 return NO_ERROR;
1449 }
1450 case GET_DISPLAY_CONFIGS: {
1451 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1452 Vector<DisplayConfig> configs;
1453 const sp<IBinder> display = data.readStrongBinder();
1454 const status_t result = getDisplayConfigs(display, &configs);
1455 reply->writeInt32(result);
1456 if (result == NO_ERROR) {
1457 reply->writeUint32(static_cast<uint32_t>(configs.size()));
1458 for (size_t c = 0; c < configs.size(); ++c) {
1459 memcpy(reply->writeInplace(sizeof(DisplayConfig)), &configs[c],
1460 sizeof(DisplayConfig));
1461 }
1462 }
1463 return NO_ERROR;
1464 }
1465 case GET_DISPLAY_STATS: {
1466 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1467 DisplayStatInfo stats;
1468 sp<IBinder> display = data.readStrongBinder();
1469 status_t result = getDisplayStats(display, &stats);
1470 reply->writeInt32(result);
1471 if (result == NO_ERROR) {
1472 memcpy(reply->writeInplace(sizeof(DisplayStatInfo)),
1473 &stats, sizeof(DisplayStatInfo));
1474 }
1475 return NO_ERROR;
1476 }
1477 case GET_ACTIVE_CONFIG: {
1478 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1479 sp<IBinder> display = data.readStrongBinder();
1480 int id = getActiveConfig(display);
1481 reply->writeInt32(id);
1482 return NO_ERROR;
1483 }
1484 case GET_DISPLAY_COLOR_MODES: {
1485 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1486 Vector<ColorMode> colorModes;
1487 sp<IBinder> display = nullptr;
1488 status_t result = data.readStrongBinder(&display);
1489 if (result != NO_ERROR) {
1490 ALOGE("getDisplayColorModes failed to readStrongBinder: %d", result);
1491 return result;
1492 }
1493 result = getDisplayColorModes(display, &colorModes);
1494 reply->writeInt32(result);
1495 if (result == NO_ERROR) {
1496 reply->writeUint32(static_cast<uint32_t>(colorModes.size()));
1497 for (size_t i = 0; i < colorModes.size(); ++i) {
1498 reply->writeInt32(static_cast<int32_t>(colorModes[i]));
1499 }
1500 }
1501 return NO_ERROR;
1502 }
1503 case GET_DISPLAY_NATIVE_PRIMARIES: {
1504 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1505 ui::DisplayPrimaries primaries;
1506 sp<IBinder> display = nullptr;
1507
1508 status_t result = data.readStrongBinder(&display);
1509 if (result != NO_ERROR) {
1510 ALOGE("getDisplayNativePrimaries failed to readStrongBinder: %d", result);
1511 return result;
1512 }
1513
1514 result = getDisplayNativePrimaries(display, primaries);
1515 reply->writeInt32(result);
1516 if (result == NO_ERROR) {
1517 memcpy(reply->writeInplace(sizeof(ui::DisplayPrimaries)), &primaries,
1518 sizeof(ui::DisplayPrimaries));
1519 }
1520
1521 return NO_ERROR;
1522 }
1523 case GET_ACTIVE_COLOR_MODE: {
1524 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1525 sp<IBinder> display = nullptr;
1526 status_t result = data.readStrongBinder(&display);
1527 if (result != NO_ERROR) {
1528 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);
1529 return result;
1530 }
1531 ColorMode colorMode = getActiveColorMode(display);
1532 result = reply->writeInt32(static_cast<int32_t>(colorMode));
1533 return result;
1534 }
1535 case SET_ACTIVE_COLOR_MODE: {
1536 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1537 sp<IBinder> display = nullptr;
1538 status_t result = data.readStrongBinder(&display);
1539 if (result != NO_ERROR) {
1540 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result);
1541 return result;
1542 }
1543 int32_t colorModeInt = 0;
1544 result = data.readInt32(&colorModeInt);
1545 if (result != NO_ERROR) {
1546 ALOGE("setActiveColorMode failed to readInt32: %d", result);
1547 return result;
1548 }
1549 result = setActiveColorMode(display,
1550 static_cast<ColorMode>(colorModeInt));
1551 result = reply->writeInt32(result);
1552 return result;
1553 }
1554
1555 case GET_AUTO_LOW_LATENCY_MODE_SUPPORT: {
1556 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1557 sp<IBinder> display = nullptr;
1558 status_t result = data.readStrongBinder(&display);
1559 if (result != NO_ERROR) {
1560 ALOGE("getAutoLowLatencyModeSupport failed to readStrongBinder: %d", result);
1561 return result;
1562 }
1563 bool supported = false;
1564 result = getAutoLowLatencyModeSupport(display, &supported);
1565 if (result == NO_ERROR) {
1566 result = reply->writeBool(supported);
1567 }
1568 return result;
1569 }
1570
1571 case SET_AUTO_LOW_LATENCY_MODE: {
1572 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1573 sp<IBinder> display = nullptr;
1574 status_t result = data.readStrongBinder(&display);
1575 if (result != NO_ERROR) {
1576 ALOGE("setAutoLowLatencyMode failed to readStrongBinder: %d", result);
1577 return result;
1578 }
1579 bool setAllm = false;
1580 result = data.readBool(&setAllm);
1581 if (result != NO_ERROR) {
1582 ALOGE("setAutoLowLatencyMode failed to readBool: %d", result);
1583 return result;
1584 }
1585 setAutoLowLatencyMode(display, setAllm);
1586 return result;
1587 }
1588
1589 case GET_GAME_CONTENT_TYPE_SUPPORT: {
1590 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1591 sp<IBinder> display = nullptr;
1592 status_t result = data.readStrongBinder(&display);
1593 if (result != NO_ERROR) {
1594 ALOGE("getGameContentTypeSupport failed to readStrongBinder: %d", result);
1595 return result;
1596 }
1597 bool supported = false;
1598 result = getGameContentTypeSupport(display, &supported);
1599 if (result == NO_ERROR) {
1600 result = reply->writeBool(supported);
1601 }
1602 return result;
1603 }
1604
1605 case SET_GAME_CONTENT_TYPE: {
1606 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1607 sp<IBinder> display = nullptr;
1608 status_t result = data.readStrongBinder(&display);
1609 if (result != NO_ERROR) {
1610 ALOGE("setGameContentType failed to readStrongBinder: %d", result);
1611 return result;
1612 }
1613 bool setGameContentTypeOn = false;
1614 result = data.readBool(&setGameContentTypeOn);
1615 if (result != NO_ERROR) {
1616 ALOGE("setGameContentType failed to readBool: %d", result);
1617 return result;
1618 }
1619 setGameContentType(display, setGameContentTypeOn);
1620 return result;
1621 }
1622
1623 case CLEAR_ANIMATION_FRAME_STATS: {
1624 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1625 status_t result = clearAnimationFrameStats();
1626 reply->writeInt32(result);
1627 return NO_ERROR;
1628 }
1629 case GET_ANIMATION_FRAME_STATS: {
1630 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1631 FrameStats stats;
1632 status_t result = getAnimationFrameStats(&stats);
1633 reply->write(stats);
1634 reply->writeInt32(result);
1635 return NO_ERROR;
1636 }
1637 case SET_POWER_MODE: {
1638 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1639 sp<IBinder> display = data.readStrongBinder();
1640 int32_t mode = data.readInt32();
1641 setPowerMode(display, mode);
1642 return NO_ERROR;
1643 }
1644 case GET_HDR_CAPABILITIES: {
1645 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1646 sp<IBinder> display = nullptr;
1647 status_t result = data.readStrongBinder(&display);
1648 if (result != NO_ERROR) {
1649 ALOGE("getHdrCapabilities failed to readStrongBinder: %d",
1650 result);
1651 return result;
1652 }
1653 HdrCapabilities capabilities;
1654 result = getHdrCapabilities(display, &capabilities);
1655 reply->writeInt32(result);
1656 if (result == NO_ERROR) {
1657 reply->write(capabilities);
1658 }
1659 return NO_ERROR;
1660 }
1661 case ENABLE_VSYNC_INJECTIONS: {
1662 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1663 bool enable = false;
1664 status_t result = data.readBool(&enable);
1665 if (result != NO_ERROR) {
1666 ALOGE("enableVSyncInjections failed to readBool: %d", result);
1667 return result;
1668 }
1669 return enableVSyncInjections(enable);
1670 }
1671 case INJECT_VSYNC: {
1672 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1673 int64_t when = 0;
1674 status_t result = data.readInt64(&when);
1675 if (result != NO_ERROR) {
1676 ALOGE("enableVSyncInjections failed to readInt64: %d", result);
1677 return result;
1678 }
1679 return injectVSync(when);
1680 }
1681 case GET_LAYER_DEBUG_INFO: {
1682 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1683 std::vector<LayerDebugInfo> outLayers;
1684 status_t result = getLayerDebugInfo(&outLayers);
1685 reply->writeInt32(result);
1686 if (result == NO_ERROR)
1687 {
1688 result = reply->writeParcelableVector(outLayers);
1689 }
1690 return result;
1691 }
1692 case GET_COMPOSITION_PREFERENCE: {
1693 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1694 ui::Dataspace defaultDataspace;
1695 ui::PixelFormat defaultPixelFormat;
1696 ui::Dataspace wideColorGamutDataspace;
1697 ui::PixelFormat wideColorGamutPixelFormat;
1698 status_t error =
1699 getCompositionPreference(&defaultDataspace, &defaultPixelFormat,
1700 &wideColorGamutDataspace, &wideColorGamutPixelFormat);
1701 reply->writeInt32(error);
1702 if (error == NO_ERROR) {
1703 reply->writeInt32(static_cast<int32_t>(defaultDataspace));
1704 reply->writeInt32(static_cast<int32_t>(defaultPixelFormat));
1705 reply->writeInt32(static_cast<int32_t>(wideColorGamutDataspace));
1706 reply->writeInt32(static_cast<int32_t>(wideColorGamutPixelFormat));
1707 }
1708 return error;
1709 }
1710 case GET_COLOR_MANAGEMENT: {
1711 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1712 bool result;
1713 status_t error = getColorManagement(&result);
1714 if (error == NO_ERROR) {
1715 reply->writeBool(result);
1716 }
1717 return error;
1718 }
1719 case GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES: {
1720 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1721
1722 sp<IBinder> display = data.readStrongBinder();
1723 ui::PixelFormat format;
1724 ui::Dataspace dataspace;
1725 uint8_t component = 0;
1726 auto result =
1727 getDisplayedContentSamplingAttributes(display, &format, &dataspace, &component);
1728 if (result == NO_ERROR) {
1729 reply->writeUint32(static_cast<uint32_t>(format));
1730 reply->writeUint32(static_cast<uint32_t>(dataspace));
1731 reply->writeUint32(static_cast<uint32_t>(component));
1732 }
1733 return result;
1734 }
1735 case SET_DISPLAY_CONTENT_SAMPLING_ENABLED: {
1736 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1737
1738 sp<IBinder> display = nullptr;
1739 bool enable = false;
1740 int8_t componentMask = 0;
1741 uint64_t maxFrames = 0;
1742 status_t result = data.readStrongBinder(&display);
1743 if (result != NO_ERROR) {
1744 ALOGE("setDisplayContentSamplingEnabled failure in reading Display token: %d",
1745 result);
1746 return result;
1747 }
1748
1749 result = data.readBool(&enable);
1750 if (result != NO_ERROR) {
1751 ALOGE("setDisplayContentSamplingEnabled failure in reading enable: %d", result);
1752 return result;
1753 }
1754
1755 result = data.readByte(static_cast<int8_t*>(&componentMask));
1756 if (result != NO_ERROR) {
1757 ALOGE("setDisplayContentSamplingEnabled failure in reading component mask: %d",
1758 result);
1759 return result;
1760 }
1761
1762 result = data.readUint64(&maxFrames);
1763 if (result != NO_ERROR) {
1764 ALOGE("setDisplayContentSamplingEnabled failure in reading max frames: %d", result);
1765 return result;
1766 }
1767
1768 return setDisplayContentSamplingEnabled(display, enable,
1769 static_cast<uint8_t>(componentMask), maxFrames);
1770 }
1771 case GET_DISPLAYED_CONTENT_SAMPLE: {
1772 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1773
1774 sp<IBinder> display = data.readStrongBinder();
1775 uint64_t maxFrames = 0;
1776 uint64_t timestamp = 0;
1777
1778 status_t result = data.readUint64(&maxFrames);
1779 if (result != NO_ERROR) {
1780 ALOGE("getDisplayedContentSample failure in reading max frames: %d", result);
1781 return result;
1782 }
1783
1784 result = data.readUint64(×tamp);
1785 if (result != NO_ERROR) {
1786 ALOGE("getDisplayedContentSample failure in reading timestamp: %d", result);
1787 return result;
1788 }
1789
1790 DisplayedFrameStats stats;
1791 result = getDisplayedContentSample(display, maxFrames, timestamp, &stats);
1792 if (result == NO_ERROR) {
1793 reply->writeUint64(stats.numFrames);
1794 reply->writeUint64Vector(stats.component_0_sample);
1795 reply->writeUint64Vector(stats.component_1_sample);
1796 reply->writeUint64Vector(stats.component_2_sample);
1797 reply->writeUint64Vector(stats.component_3_sample);
1798 }
1799 return result;
1800 }
1801 case GET_PROTECTED_CONTENT_SUPPORT: {
1802 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1803 bool result;
1804 status_t error = getProtectedContentSupport(&result);
1805 if (error == NO_ERROR) {
1806 reply->writeBool(result);
1807 }
1808 return error;
1809 }
1810 case IS_WIDE_COLOR_DISPLAY: {
1811 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1812 sp<IBinder> display = nullptr;
1813 status_t error = data.readStrongBinder(&display);
1814 if (error != NO_ERROR) {
1815 return error;
1816 }
1817 bool result;
1818 error = isWideColorDisplay(display, &result);
1819 if (error == NO_ERROR) {
1820 reply->writeBool(result);
1821 }
1822 return error;
1823 }
1824 case GET_PHYSICAL_DISPLAY_IDS: {
1825 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1826 return reply->writeUint64Vector(getPhysicalDisplayIds());
1827 }
1828 case ADD_REGION_SAMPLING_LISTENER: {
1829 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1830 Rect samplingArea;
1831 status_t result = data.read(samplingArea);
1832 if (result != NO_ERROR) {
1833 ALOGE("addRegionSamplingListener: Failed to read sampling area");
1834 return result;
1835 }
1836 sp<IBinder> stopLayerHandle;
1837 result = data.readNullableStrongBinder(&stopLayerHandle);
1838 if (result != NO_ERROR) {
1839 ALOGE("addRegionSamplingListener: Failed to read stop layer handle");
1840 return result;
1841 }
1842 sp<IRegionSamplingListener> listener;
1843 result = data.readNullableStrongBinder(&listener);
1844 if (result != NO_ERROR) {
1845 ALOGE("addRegionSamplingListener: Failed to read listener");
1846 return result;
1847 }
1848 return addRegionSamplingListener(samplingArea, stopLayerHandle, listener);
1849 }
1850 case REMOVE_REGION_SAMPLING_LISTENER: {
1851 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1852 sp<IRegionSamplingListener> listener;
1853 status_t result = data.readNullableStrongBinder(&listener);
1854 if (result != NO_ERROR) {
1855 ALOGE("removeRegionSamplingListener: Failed to read listener");
1856 return result;
1857 }
1858 return removeRegionSamplingListener(listener);
1859 }
1860 case SET_DESIRED_DISPLAY_CONFIG_SPECS: {
1861 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1862 sp<IBinder> displayToken = data.readStrongBinder();
1863 int32_t defaultConfig;
1864 status_t result = data.readInt32(&defaultConfig);
1865 if (result != NO_ERROR) {
1866 ALOGE("setDesiredDisplayConfigSpecs: failed to read defaultConfig: %d", result);
1867 return result;
1868 }
1869 float primaryRefreshRateMin;
1870 result = data.readFloat(&primaryRefreshRateMin);
1871 if (result != NO_ERROR) {
1872 ALOGE("setDesiredDisplayConfigSpecs: failed to read primaryRefreshRateMin: %d",
1873 result);
1874 return result;
1875 }
1876 float primaryRefreshRateMax;
1877 result = data.readFloat(&primaryRefreshRateMax);
1878 if (result != NO_ERROR) {
1879 ALOGE("setDesiredDisplayConfigSpecs: failed to read primaryRefreshRateMax: %d",
1880 result);
1881 return result;
1882 }
1883 float appRequestRefreshRateMin;
1884 result = data.readFloat(&appRequestRefreshRateMin);
1885 if (result != NO_ERROR) {
1886 ALOGE("setDesiredDisplayConfigSpecs: failed to read appRequestRefreshRateMin: %d",
1887 result);
1888 return result;
1889 }
1890 float appRequestRefreshRateMax;
1891 result = data.readFloat(&appRequestRefreshRateMax);
1892 if (result != NO_ERROR) {
1893 ALOGE("setDesiredDisplayConfigSpecs: failed to read appRequestRefreshRateMax: %d",
1894 result);
1895 return result;
1896 }
1897 result =
1898 setDesiredDisplayConfigSpecs(displayToken, defaultConfig, primaryRefreshRateMin,
1899 primaryRefreshRateMax, appRequestRefreshRateMin,
1900 appRequestRefreshRateMax);
1901 if (result != NO_ERROR) {
1902 ALOGE("setDesiredDisplayConfigSpecs: failed to call setDesiredDisplayConfigSpecs: "
1903 "%d",
1904 result);
1905 return result;
1906 }
1907 reply->writeInt32(result);
1908 return result;
1909 }
1910 case GET_DESIRED_DISPLAY_CONFIG_SPECS: {
1911 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1912 sp<IBinder> displayToken = data.readStrongBinder();
1913 int32_t defaultConfig;
1914 float primaryRefreshRateMin;
1915 float primaryRefreshRateMax;
1916 float appRequestRefreshRateMin;
1917 float appRequestRefreshRateMax;
1918
1919 status_t result =
1920 getDesiredDisplayConfigSpecs(displayToken, &defaultConfig,
1921 &primaryRefreshRateMin, &primaryRefreshRateMax,
1922 &appRequestRefreshRateMin,
1923 &appRequestRefreshRateMax);
1924 if (result != NO_ERROR) {
1925 ALOGE("getDesiredDisplayConfigSpecs: failed to get getDesiredDisplayConfigSpecs: "
1926 "%d",
1927 result);
1928 return result;
1929 }
1930
1931 result = reply->writeInt32(defaultConfig);
1932 if (result != NO_ERROR) {
1933 ALOGE("getDesiredDisplayConfigSpecs: failed to write defaultConfig: %d", result);
1934 return result;
1935 }
1936 result = reply->writeFloat(primaryRefreshRateMin);
1937 if (result != NO_ERROR) {
1938 ALOGE("getDesiredDisplayConfigSpecs: failed to write primaryRefreshRateMin: %d",
1939 result);
1940 return result;
1941 }
1942 result = reply->writeFloat(primaryRefreshRateMax);
1943 if (result != NO_ERROR) {
1944 ALOGE("getDesiredDisplayConfigSpecs: failed to write primaryRefreshRateMax: %d",
1945 result);
1946 return result;
1947 }
1948 result = reply->writeFloat(appRequestRefreshRateMin);
1949 if (result != NO_ERROR) {
1950 ALOGE("getDesiredDisplayConfigSpecs: failed to write appRequestRefreshRateMin: %d",
1951 result);
1952 return result;
1953 }
1954 result = reply->writeFloat(appRequestRefreshRateMax);
1955 if (result != NO_ERROR) {
1956 ALOGE("getDesiredDisplayConfigSpecs: failed to write appRequestRefreshRateMax: %d",
1957 result);
1958 return result;
1959 }
1960 reply->writeInt32(result);
1961 return result;
1962 }
1963 case GET_DISPLAY_BRIGHTNESS_SUPPORT: {
1964 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1965 sp<IBinder> displayToken;
1966 status_t error = data.readNullableStrongBinder(&displayToken);
1967 if (error != NO_ERROR) {
1968 ALOGE("getDisplayBrightnessSupport: failed to read display token: %d", error);
1969 return error;
1970 }
1971 bool support = false;
1972 error = getDisplayBrightnessSupport(displayToken, &support);
1973 reply->writeBool(support);
1974 return error;
1975 }
1976 case SET_DISPLAY_BRIGHTNESS: {
1977 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1978 sp<IBinder> displayToken;
1979 status_t error = data.readNullableStrongBinder(&displayToken);
1980 if (error != NO_ERROR) {
1981 ALOGE("setDisplayBrightness: failed to read display token: %d", error);
1982 return error;
1983 }
1984 float brightness = -1.0f;
1985 error = data.readFloat(&brightness);
1986 if (error != NO_ERROR) {
1987 ALOGE("setDisplayBrightness: failed to read brightness: %d", error);
1988 return error;
1989 }
1990 return setDisplayBrightness(displayToken, brightness);
1991 }
1992 case NOTIFY_POWER_HINT: {
1993 CHECK_INTERFACE(ISurfaceComposer, data, reply);
1994 int32_t hintId;
1995 status_t error = data.readInt32(&hintId);
1996 if (error != NO_ERROR) {
1997 ALOGE("notifyPowerHint: failed to read hintId: %d", error);
1998 return error;
1999 }
2000 return notifyPowerHint(hintId);
2001 }
2002 case SET_GLOBAL_SHADOW_SETTINGS: {
2003 CHECK_INTERFACE(ISurfaceComposer, data, reply);
2004
2005 std::vector<float> shadowConfig;
2006 status_t error = data.readFloatVector(&shadowConfig);
2007 if (error != NO_ERROR || shadowConfig.size() != 11) {
2008 ALOGE("setGlobalShadowSettings: failed to read shadowConfig: %d", error);
2009 return error;
2010 }
2011
2012 half4 ambientColor = {shadowConfig[0], shadowConfig[1], shadowConfig[2],
2013 shadowConfig[3]};
2014 half4 spotColor = {shadowConfig[4], shadowConfig[5], shadowConfig[6], shadowConfig[7]};
2015 float lightPosY = shadowConfig[8];
2016 float lightPosZ = shadowConfig[9];
2017 float lightRadius = shadowConfig[10];
2018 return setGlobalShadowSettings(ambientColor, spotColor, lightPosY, lightPosZ,
2019 lightRadius);
2020 }
2021 case SET_FRAME_RATE: {
2022 CHECK_INTERFACE(ISurfaceComposer, data, reply);
2023 sp<IBinder> binder;
2024 status_t err = data.readStrongBinder(&binder);
2025 if (err != NO_ERROR) {
2026 ALOGE("setFrameRate: failed to read strong binder: %s (%d)", strerror(-err), -err);
2027 return err;
2028 }
2029 sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder);
2030 if (!surface) {
2031 ALOGE("setFrameRate: failed to cast to IGraphicBufferProducer: %s (%d)",
2032 strerror(-err), -err);
2033 return err;
2034 }
2035 float frameRate;
2036 err = data.readFloat(&frameRate);
2037 if (err != NO_ERROR) {
2038 ALOGE("setFrameRate: failed to read float: %s (%d)", strerror(-err), -err);
2039 return err;
2040 }
2041 int8_t compatibility;
2042 err = data.readByte(&compatibility);
2043 if (err != NO_ERROR) {
2044 ALOGE("setFrameRate: failed to read byte: %s (%d)", strerror(-err), -err);
2045 return err;
2046 }
2047 status_t result = setFrameRate(surface, frameRate, compatibility);
2048 reply->writeInt32(result);
2049 return NO_ERROR;
2050 }
2051 case ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN: {
2052 CHECK_INTERFACE(ISurfaceComposer, data, reply);
2053 sp<IBinder> token;
2054 status_t result = acquireFrameRateFlexibilityToken(&token);
2055 reply->writeInt32(result);
2056 if (result == NO_ERROR) {
2057 reply->writeStrongBinder(token);
2058 }
2059 return NO_ERROR;
2060 }
2061 default: {
2062 return BBinder::onTransact(code, data, reply, flags);
2063 }
2064 }
2065 }
2066
2067 } // namespace android
2068