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