1 /*
2 * Copyright 2016 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 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20 #undef LOG_TAG
21 #define LOG_TAG "SurfaceInterceptor"
22 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
23
24 #include "Layer.h"
25 #include "SurfaceFlinger.h"
26 #include "SurfaceInterceptor.h"
27
28 #include <fstream>
29
30 #include <android-base/file.h>
31 #include <log/log.h>
32 #include <utils/Trace.h>
33
34 namespace android {
35
36 // ----------------------------------------------------------------------------
37 // TODO(marissaw): add new layer state values to SurfaceInterceptor
38
39 SurfaceInterceptor::~SurfaceInterceptor() = default;
40
41 namespace impl {
42
addTransactionTraceListener(const sp<gui::ITransactionTraceListener> & listener)43 void SurfaceInterceptor::addTransactionTraceListener(
44 const sp<gui::ITransactionTraceListener>& listener) {
45 sp<IBinder> asBinder = IInterface::asBinder(listener);
46
47 std::scoped_lock lock(mListenersMutex);
48
49 asBinder->linkToDeath(this);
50
51 listener->onToggled(mEnabled); // notifies of current state
52
53 mTraceToggledListeners.emplace(asBinder, listener);
54 }
55
binderDied(const wp<IBinder> & who)56 void SurfaceInterceptor::binderDied(const wp<IBinder>& who) {
57 std::scoped_lock lock(mListenersMutex);
58 mTraceToggledListeners.erase(who);
59 }
60
enable(const SortedVector<sp<Layer>> & layers,const DefaultKeyedVector<wp<IBinder>,DisplayDeviceState> & displays)61 void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers,
62 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
63 {
64 if (mEnabled) {
65 return;
66 }
67 ATRACE_CALL();
68 {
69 std::scoped_lock lock(mListenersMutex);
70 for (const auto& [_, listener] : mTraceToggledListeners) {
71 listener->onToggled(true);
72 }
73 }
74 mEnabled = true;
75 std::scoped_lock<std::mutex> protoGuard(mTraceMutex);
76 saveExistingDisplaysLocked(displays);
77 saveExistingSurfacesLocked(layers);
78 }
79
disable()80 void SurfaceInterceptor::disable() {
81 if (!mEnabled) {
82 return;
83 }
84 ATRACE_CALL();
85 {
86 std::scoped_lock lock(mListenersMutex);
87 for (const auto& [_, listener] : mTraceToggledListeners) {
88 listener->onToggled(false);
89 }
90 }
91 mEnabled = false;
92 std::scoped_lock<std::mutex> protoGuard(mTraceMutex);
93 status_t err(writeProtoFileLocked());
94 ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
95 ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
96 mTrace.Clear();
97 }
98
isEnabled()99 bool SurfaceInterceptor::isEnabled() {
100 return mEnabled;
101 }
102
saveExistingDisplaysLocked(const DefaultKeyedVector<wp<IBinder>,DisplayDeviceState> & displays)103 void SurfaceInterceptor::saveExistingDisplaysLocked(
104 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
105 {
106 // Caveat: The initial snapshot does not capture the power mode of the existing displays
107 ATRACE_CALL();
108 for (size_t i = 0 ; i < displays.size() ; i++) {
109 addDisplayCreationLocked(createTraceIncrementLocked(), displays[i]);
110 addInitialDisplayStateLocked(createTraceIncrementLocked(), displays[i]);
111 }
112 }
113
saveExistingSurfacesLocked(const SortedVector<sp<Layer>> & layers)114 void SurfaceInterceptor::saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers) {
115 ATRACE_CALL();
116 for (const auto& l : layers) {
117 l->traverseInZOrder(LayerVector::StateSet::Drawing, [this](Layer* layer) {
118 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
119 addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer);
120 });
121 }
122 }
123
addInitialSurfaceStateLocked(Increment * increment,const sp<const Layer> & layer)124 void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment,
125 const sp<const Layer>& layer)
126 {
127 Transaction* transaction(increment->mutable_transaction());
128 const uint32_t layerFlags = layer->getTransactionFlags();
129 transaction->set_synchronous(layerFlags & BnSurfaceComposer::eSynchronous);
130 transaction->set_animation(layerFlags & BnSurfaceComposer::eAnimation);
131
132 const int32_t layerId(getLayerId(layer));
133 addPositionLocked(transaction, layerId, layer->mDrawingState.transform.tx(),
134 layer->mDrawingState.transform.ty());
135 addDepthLocked(transaction, layerId, layer->mDrawingState.z);
136 addAlphaLocked(transaction, layerId, layer->mDrawingState.color.a);
137 addTransparentRegionLocked(transaction, layerId,
138 layer->mDrawingState.activeTransparentRegion_legacy);
139 addLayerStackLocked(transaction, layerId, layer->mDrawingState.layerStack);
140 addCropLocked(transaction, layerId, layer->mDrawingState.crop);
141 addCornerRadiusLocked(transaction, layerId, layer->mDrawingState.cornerRadius);
142 addBackgroundBlurRadiusLocked(transaction, layerId, layer->mDrawingState.backgroundBlurRadius);
143 addBlurRegionsLocked(transaction, layerId, layer->mDrawingState.blurRegions);
144 addFlagsLocked(transaction, layerId, layer->mDrawingState.flags,
145 layer_state_t::eLayerHidden | layer_state_t::eLayerOpaque |
146 layer_state_t::eLayerSecure);
147 addReparentLocked(transaction, layerId, getLayerIdFromWeakRef(layer->mDrawingParent));
148 addRelativeParentLocked(transaction, layerId,
149 getLayerIdFromWeakRef(layer->mDrawingState.zOrderRelativeOf),
150 layer->mDrawingState.z);
151 addShadowRadiusLocked(transaction, layerId, layer->mDrawingState.shadowRadius);
152 addTrustedOverlayLocked(transaction, layerId, layer->mDrawingState.isTrustedOverlay);
153 }
154
addInitialDisplayStateLocked(Increment * increment,const DisplayDeviceState & display)155 void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
156 const DisplayDeviceState& display)
157 {
158 Transaction* transaction(increment->mutable_transaction());
159 transaction->set_synchronous(false);
160 transaction->set_animation(false);
161
162 addDisplaySurfaceLocked(transaction, display.sequenceId, display.surface);
163 addDisplayLayerStackLocked(transaction, display.sequenceId, display.layerStack);
164 addDisplaySizeLocked(transaction, display.sequenceId, display.width, display.height);
165 addDisplayProjectionLocked(transaction, display.sequenceId, toRotationInt(display.orientation),
166 display.layerStackSpaceRect, display.orientedDisplaySpaceRect);
167 }
168
writeProtoFileLocked()169 status_t SurfaceInterceptor::writeProtoFileLocked() {
170 ATRACE_CALL();
171 std::string output;
172
173 if (!mTrace.IsInitialized()) {
174 return NOT_ENOUGH_DATA;
175 }
176 if (!mTrace.SerializeToString(&output)) {
177 return PERMISSION_DENIED;
178 }
179 if (!android::base::WriteStringToFile(output, mOutputFileName, true)) {
180 return PERMISSION_DENIED;
181 }
182
183 return NO_ERROR;
184 }
185
getLayer(const wp<const IBinder> & weakHandle) const186 const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) const {
187 const sp<const IBinder>& handle(weakHandle.promote());
188 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
189 const sp<const Layer> layer(layerHandle->owner.promote());
190 // layer could be a nullptr at this point
191 return layer;
192 }
193
getLayerId(const sp<const Layer> & layer) const194 int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) const {
195 return layer->sequence;
196 }
197
getLayerIdFromWeakRef(const wp<const Layer> & layer) const198 int32_t SurfaceInterceptor::getLayerIdFromWeakRef(const wp<const Layer>& layer) const {
199 if (layer == nullptr) {
200 return -1;
201 }
202 auto strongLayer = layer.promote();
203 return strongLayer == nullptr ? -1 : getLayerId(strongLayer);
204 }
205
getLayerIdFromHandle(const sp<const IBinder> & handle) const206 int32_t SurfaceInterceptor::getLayerIdFromHandle(const sp<const IBinder>& handle) const {
207 if (handle == nullptr) {
208 return -1;
209 }
210 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
211 const sp<const Layer> layer(layerHandle->owner.promote());
212 return layer == nullptr ? -1 : getLayerId(layer);
213 }
214
createTraceIncrementLocked()215 Increment* SurfaceInterceptor::createTraceIncrementLocked() {
216 Increment* increment(mTrace.add_increment());
217 increment->set_time_stamp(elapsedRealtimeNano());
218 return increment;
219 }
220
createSurfaceChangeLocked(Transaction * transaction,int32_t layerId)221 SurfaceChange* SurfaceInterceptor::createSurfaceChangeLocked(Transaction* transaction,
222 int32_t layerId)
223 {
224 SurfaceChange* change(transaction->add_surface_change());
225 change->set_id(layerId);
226 return change;
227 }
228
createDisplayChangeLocked(Transaction * transaction,int32_t sequenceId)229 DisplayChange* SurfaceInterceptor::createDisplayChangeLocked(Transaction* transaction,
230 int32_t sequenceId)
231 {
232 DisplayChange* dispChange(transaction->add_display_change());
233 dispChange->set_id(sequenceId);
234 return dispChange;
235 }
236
setProtoRectLocked(Rectangle * protoRect,const Rect & rect)237 void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
238 protoRect->set_left(rect.left);
239 protoRect->set_top(rect.top);
240 protoRect->set_right(rect.right);
241 protoRect->set_bottom(rect.bottom);
242 }
243
setTransactionOriginLocked(Transaction * transaction,int32_t pid,int32_t uid)244 void SurfaceInterceptor::setTransactionOriginLocked(Transaction* transaction, int32_t pid,
245 int32_t uid) {
246 Origin* origin(transaction->mutable_origin());
247 origin->set_pid(pid);
248 origin->set_uid(uid);
249 }
250
addPositionLocked(Transaction * transaction,int32_t layerId,float x,float y)251 void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId,
252 float x, float y)
253 {
254 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
255 PositionChange* posChange(change->mutable_position());
256 posChange->set_x(x);
257 posChange->set_y(y);
258 }
259
addDepthLocked(Transaction * transaction,int32_t layerId,uint32_t z)260 void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId,
261 uint32_t z)
262 {
263 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
264 LayerChange* depthChange(change->mutable_layer());
265 depthChange->set_layer(z);
266 }
267
addSizeLocked(Transaction * transaction,int32_t layerId,uint32_t w,uint32_t h)268 void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
269 uint32_t h)
270 {
271 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
272 SizeChange* sizeChange(change->mutable_size());
273 sizeChange->set_w(w);
274 sizeChange->set_h(h);
275 }
276
addAlphaLocked(Transaction * transaction,int32_t layerId,float alpha)277 void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId,
278 float alpha)
279 {
280 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
281 AlphaChange* alphaChange(change->mutable_alpha());
282 alphaChange->set_alpha(alpha);
283 }
284
addMatrixLocked(Transaction * transaction,int32_t layerId,const layer_state_t::matrix22_t & matrix)285 void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
286 const layer_state_t::matrix22_t& matrix)
287 {
288 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
289 MatrixChange* matrixChange(change->mutable_matrix());
290 matrixChange->set_dsdx(matrix.dsdx);
291 matrixChange->set_dtdx(matrix.dtdx);
292 matrixChange->set_dsdy(matrix.dsdy);
293 matrixChange->set_dtdy(matrix.dtdy);
294 }
295
addTransparentRegionLocked(Transaction * transaction,int32_t layerId,const Region & transRegion)296 void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction,
297 int32_t layerId, const Region& transRegion)
298 {
299 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
300 TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());
301
302 for (const auto& rect : transRegion) {
303 Rectangle* protoRect(transparentChange->add_region());
304 setProtoRectLocked(protoRect, rect);
305 }
306 }
307
addFlagsLocked(Transaction * transaction,int32_t layerId,uint8_t flags,uint8_t mask)308 void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags,
309 uint8_t mask) {
310 // There can be multiple flags changed
311 if (mask & layer_state_t::eLayerHidden) {
312 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
313 HiddenFlagChange* flagChange(change->mutable_hidden_flag());
314 flagChange->set_hidden_flag(flags & layer_state_t::eLayerHidden);
315 }
316 if (mask & layer_state_t::eLayerOpaque) {
317 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
318 OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
319 flagChange->set_opaque_flag(flags & layer_state_t::eLayerOpaque);
320 }
321 if (mask & layer_state_t::eLayerSecure) {
322 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
323 SecureFlagChange* flagChange(change->mutable_secure_flag());
324 flagChange->set_secure_flag(flags & layer_state_t::eLayerSecure);
325 }
326 }
327
addLayerStackLocked(Transaction * transaction,int32_t layerId,uint32_t layerStack)328 void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
329 uint32_t layerStack)
330 {
331 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
332 LayerStackChange* layerStackChange(change->mutable_layer_stack());
333 layerStackChange->set_layer_stack(layerStack);
334 }
335
addCropLocked(Transaction * transaction,int32_t layerId,const Rect & rect)336 void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
337 const Rect& rect)
338 {
339 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
340 CropChange* cropChange(change->mutable_crop());
341 Rectangle* protoRect(cropChange->mutable_rectangle());
342 setProtoRectLocked(protoRect, rect);
343 }
344
addCornerRadiusLocked(Transaction * transaction,int32_t layerId,float cornerRadius)345 void SurfaceInterceptor::addCornerRadiusLocked(Transaction* transaction, int32_t layerId,
346 float cornerRadius)
347 {
348 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
349 CornerRadiusChange* cornerRadiusChange(change->mutable_corner_radius());
350 cornerRadiusChange->set_corner_radius(cornerRadius);
351 }
352
addBackgroundBlurRadiusLocked(Transaction * transaction,int32_t layerId,int32_t backgroundBlurRadius)353 void SurfaceInterceptor::addBackgroundBlurRadiusLocked(Transaction* transaction, int32_t layerId,
354 int32_t backgroundBlurRadius) {
355 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
356 BackgroundBlurRadiusChange* blurRadiusChange(change->mutable_background_blur_radius());
357 blurRadiusChange->set_background_blur_radius(backgroundBlurRadius);
358 }
359
addBlurRegionsLocked(Transaction * transaction,int32_t layerId,const std::vector<BlurRegion> & blurRegions)360 void SurfaceInterceptor::addBlurRegionsLocked(Transaction* transaction, int32_t layerId,
361 const std::vector<BlurRegion>& blurRegions) {
362 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
363 BlurRegionsChange* blurRegionsChange(change->mutable_blur_regions());
364 for (const auto blurRegion : blurRegions) {
365 const auto blurRegionChange = blurRegionsChange->add_blur_regions();
366 blurRegionChange->set_blur_radius(blurRegion.blurRadius);
367 blurRegionChange->set_corner_radius_tl(blurRegion.cornerRadiusTL);
368 blurRegionChange->set_corner_radius_tr(blurRegion.cornerRadiusTR);
369 blurRegionChange->set_corner_radius_bl(blurRegion.cornerRadiusBL);
370 blurRegionChange->set_corner_radius_br(blurRegion.cornerRadiusBR);
371 blurRegionChange->set_alpha(blurRegion.alpha);
372 blurRegionChange->set_left(blurRegion.left);
373 blurRegionChange->set_top(blurRegion.top);
374 blurRegionChange->set_right(blurRegion.right);
375 blurRegionChange->set_bottom(blurRegion.bottom);
376 }
377 }
378
addReparentLocked(Transaction * transaction,int32_t layerId,int32_t parentId)379 void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId,
380 int32_t parentId) {
381 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
382 ReparentChange* overrideChange(change->mutable_reparent());
383 overrideChange->set_parent_id(parentId);
384 }
385
addRelativeParentLocked(Transaction * transaction,int32_t layerId,int32_t parentId,int z)386 void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId,
387 int32_t parentId, int z) {
388 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
389 RelativeParentChange* overrideChange(change->mutable_relative_parent());
390 overrideChange->set_relative_parent_id(parentId);
391 overrideChange->set_z(z);
392 }
393
addShadowRadiusLocked(Transaction * transaction,int32_t layerId,float shadowRadius)394 void SurfaceInterceptor::addShadowRadiusLocked(Transaction* transaction, int32_t layerId,
395 float shadowRadius) {
396 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
397 ShadowRadiusChange* overrideChange(change->mutable_shadow_radius());
398 overrideChange->set_radius(shadowRadius);
399 }
400
addTrustedOverlayLocked(Transaction * transaction,int32_t layerId,bool isTrustedOverlay)401 void SurfaceInterceptor::addTrustedOverlayLocked(Transaction* transaction, int32_t layerId,
402 bool isTrustedOverlay) {
403 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
404 TrustedOverlayChange* overrideChange(change->mutable_trusted_overlay());
405 overrideChange->set_is_trusted_overlay(isTrustedOverlay);
406 }
407
addSurfaceChangesLocked(Transaction * transaction,const layer_state_t & state)408 void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,
409 const layer_state_t& state)
410 {
411 const sp<const Layer> layer(getLayer(state.surface));
412 if (layer == nullptr) {
413 ALOGE("An existing layer could not be retrieved with the surface "
414 "from the layer_state_t surface in the update transaction");
415 return;
416 }
417
418 const int32_t layerId(getLayerId(layer));
419
420 if (state.what & layer_state_t::ePositionChanged) {
421 addPositionLocked(transaction, layerId, state.x, state.y);
422 }
423 if (state.what & layer_state_t::eLayerChanged) {
424 addDepthLocked(transaction, layerId, state.z);
425 }
426 if (state.what & layer_state_t::eSizeChanged) {
427 addSizeLocked(transaction, layerId, state.w, state.h);
428 }
429 if (state.what & layer_state_t::eAlphaChanged) {
430 addAlphaLocked(transaction, layerId, state.alpha);
431 }
432 if (state.what & layer_state_t::eMatrixChanged) {
433 addMatrixLocked(transaction, layerId, state.matrix);
434 }
435 if (state.what & layer_state_t::eTransparentRegionChanged) {
436 addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
437 }
438 if (state.what & layer_state_t::eFlagsChanged) {
439 addFlagsLocked(transaction, layerId, state.flags, state.mask);
440 }
441 if (state.what & layer_state_t::eLayerStackChanged) {
442 addLayerStackLocked(transaction, layerId, state.layerStack);
443 }
444 if (state.what & layer_state_t::eCropChanged) {
445 addCropLocked(transaction, layerId, state.crop);
446 }
447 if (state.what & layer_state_t::eCornerRadiusChanged) {
448 addCornerRadiusLocked(transaction, layerId, state.cornerRadius);
449 }
450 if (state.what & layer_state_t::eBackgroundBlurRadiusChanged) {
451 addBackgroundBlurRadiusLocked(transaction, layerId, state.backgroundBlurRadius);
452 }
453 if (state.what & layer_state_t::eBlurRegionsChanged) {
454 addBlurRegionsLocked(transaction, layerId, state.blurRegions);
455 }
456 if (state.what & layer_state_t::eReparent) {
457 auto parentHandle = (state.parentSurfaceControlForChild)
458 ? state.parentSurfaceControlForChild->getHandle()
459 : nullptr;
460 addReparentLocked(transaction, layerId, getLayerIdFromHandle(parentHandle));
461 }
462 if (state.what & layer_state_t::eRelativeLayerChanged) {
463 addRelativeParentLocked(transaction, layerId,
464 getLayerIdFromHandle(
465 state.relativeLayerSurfaceControl->getHandle()),
466 state.z);
467 }
468 if (state.what & layer_state_t::eShadowRadiusChanged) {
469 addShadowRadiusLocked(transaction, layerId, state.shadowRadius);
470 }
471 if (state.what & layer_state_t::eTrustedOverlayChanged) {
472 addTrustedOverlayLocked(transaction, layerId, state.isTrustedOverlay);
473 }
474 if (state.what & layer_state_t::eStretchChanged) {
475 ALOGW("SurfaceInterceptor not implemented for eStretchChanged");
476 }
477 }
478
addDisplayChangesLocked(Transaction * transaction,const DisplayState & state,int32_t sequenceId)479 void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,
480 const DisplayState& state, int32_t sequenceId)
481 {
482 if (state.what & DisplayState::eSurfaceChanged) {
483 addDisplaySurfaceLocked(transaction, sequenceId, state.surface);
484 }
485 if (state.what & DisplayState::eLayerStackChanged) {
486 addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack);
487 }
488 if (state.what & DisplayState::eDisplaySizeChanged) {
489 addDisplaySizeLocked(transaction, sequenceId, state.width, state.height);
490 }
491 if (state.what & DisplayState::eDisplayProjectionChanged) {
492 addDisplayProjectionLocked(transaction, sequenceId, toRotationInt(state.orientation),
493 state.layerStackSpaceRect, state.orientedDisplaySpaceRect);
494 }
495 }
496
addTransactionLocked(Increment * increment,const Vector<ComposerState> & stateUpdates,const DefaultKeyedVector<wp<IBinder>,DisplayDeviceState> & displays,const Vector<DisplayState> & changedDisplays,uint32_t transactionFlags,int originPid,int originUid,uint64_t transactionId)497 void SurfaceInterceptor::addTransactionLocked(
498 Increment* increment, const Vector<ComposerState>& stateUpdates,
499 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
500 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags, int originPid,
501 int originUid, uint64_t transactionId) {
502 Transaction* transaction(increment->mutable_transaction());
503 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous);
504 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation);
505 setTransactionOriginLocked(transaction, originPid, originUid);
506 transaction->set_id(transactionId);
507 for (const auto& compState: stateUpdates) {
508 addSurfaceChangesLocked(transaction, compState.state);
509 }
510 for (const auto& disp: changedDisplays) {
511 ssize_t dpyIdx = displays.indexOfKey(disp.token);
512 if (dpyIdx >= 0) {
513 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx));
514 addDisplayChangesLocked(transaction, disp, dispState.sequenceId);
515 }
516 }
517 }
518
addSurfaceCreationLocked(Increment * increment,const sp<const Layer> & layer)519 void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment,
520 const sp<const Layer>& layer)
521 {
522 SurfaceCreation* creation(increment->mutable_surface_creation());
523 creation->set_id(getLayerId(layer));
524 creation->set_name(layer->getName());
525 creation->set_w(layer->mDrawingState.active_legacy.w);
526 creation->set_h(layer->mDrawingState.active_legacy.h);
527 }
528
addSurfaceDeletionLocked(Increment * increment,const sp<const Layer> & layer)529 void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
530 const sp<const Layer>& layer)
531 {
532 SurfaceDeletion* deletion(increment->mutable_surface_deletion());
533 deletion->set_id(getLayerId(layer));
534 }
535
addBufferUpdateLocked(Increment * increment,int32_t layerId,uint32_t width,uint32_t height,uint64_t frameNumber)536 void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, int32_t layerId,
537 uint32_t width, uint32_t height, uint64_t frameNumber)
538 {
539 BufferUpdate* update(increment->mutable_buffer_update());
540 update->set_id(layerId);
541 update->set_w(width);
542 update->set_h(height);
543 update->set_frame_number(frameNumber);
544 }
545
addVSyncUpdateLocked(Increment * increment,nsecs_t timestamp)546 void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) {
547 VSyncEvent* event(increment->mutable_vsync_event());
548 event->set_when(timestamp);
549 }
550
addDisplaySurfaceLocked(Transaction * transaction,int32_t sequenceId,const sp<const IGraphicBufferProducer> & surface)551 void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
552 const sp<const IGraphicBufferProducer>& surface)
553 {
554 if (surface == nullptr) {
555 return;
556 }
557 uint64_t bufferQueueId = 0;
558 status_t err(surface->getUniqueId(&bufferQueueId));
559 if (err == NO_ERROR) {
560 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
561 DispSurfaceChange* surfaceChange(dispChange->mutable_surface());
562 surfaceChange->set_buffer_queue_id(bufferQueueId);
563 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string());
564 }
565 else {
566 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)",
567 strerror(-err));
568 }
569 }
570
addDisplayLayerStackLocked(Transaction * transaction,int32_t sequenceId,uint32_t layerStack)571 void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction,
572 int32_t sequenceId, uint32_t layerStack)
573 {
574 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
575 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack());
576 layerStackChange->set_layer_stack(layerStack);
577 }
578
addDisplaySizeLocked(Transaction * transaction,int32_t sequenceId,uint32_t w,uint32_t h)579 void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId,
580 uint32_t w, uint32_t h)
581 {
582 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
583 SizeChange* sizeChange(dispChange->mutable_size());
584 sizeChange->set_w(w);
585 sizeChange->set_h(h);
586 }
587
addDisplayProjectionLocked(Transaction * transaction,int32_t sequenceId,int32_t orientation,const Rect & viewport,const Rect & frame)588 void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction,
589 int32_t sequenceId, int32_t orientation, const Rect& viewport, const Rect& frame)
590 {
591 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
592 ProjectionChange* projectionChange(dispChange->mutable_projection());
593 projectionChange->set_orientation(orientation);
594 Rectangle* viewportRect(projectionChange->mutable_viewport());
595 setProtoRectLocked(viewportRect, viewport);
596 Rectangle* frameRect(projectionChange->mutable_frame());
597 setProtoRectLocked(frameRect, frame);
598 }
599
addDisplayCreationLocked(Increment * increment,const DisplayDeviceState & info)600 void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment,
601 const DisplayDeviceState& info)
602 {
603 DisplayCreation* creation(increment->mutable_display_creation());
604 creation->set_id(info.sequenceId);
605 creation->set_name(info.displayName);
606 creation->set_is_secure(info.isSecure);
607 if (info.physical) {
608 creation->set_display_id(info.physical->id.value);
609 }
610 }
611
addDisplayDeletionLocked(Increment * increment,int32_t sequenceId)612 void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t sequenceId) {
613 DisplayDeletion* deletion(increment->mutable_display_deletion());
614 deletion->set_id(sequenceId);
615 }
616
addPowerModeUpdateLocked(Increment * increment,int32_t sequenceId,int32_t mode)617 void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId,
618 int32_t mode)
619 {
620 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update());
621 powerModeUpdate->set_id(sequenceId);
622 powerModeUpdate->set_mode(mode);
623 }
624
saveTransaction(const Vector<ComposerState> & stateUpdates,const DefaultKeyedVector<wp<IBinder>,DisplayDeviceState> & displays,const Vector<DisplayState> & changedDisplays,uint32_t flags,int originPid,int originUid,uint64_t transactionId)625 void SurfaceInterceptor::saveTransaction(
626 const Vector<ComposerState>& stateUpdates,
627 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
628 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, int originUid,
629 uint64_t transactionId) {
630 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) {
631 return;
632 }
633 ATRACE_CALL();
634 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
635 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays,
636 flags, originPid, originUid, transactionId);
637 }
638
saveSurfaceCreation(const sp<const Layer> & layer)639 void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) {
640 if (!mEnabled || layer == nullptr) {
641 return;
642 }
643 ATRACE_CALL();
644 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
645 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
646 }
647
saveSurfaceDeletion(const sp<const Layer> & layer)648 void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) {
649 if (!mEnabled || layer == nullptr) {
650 return;
651 }
652 ATRACE_CALL();
653 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
654 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer);
655 }
656
657 /**
658 * Here we pass the layer by ID instead of by sp<> since this is called without
659 * holding the state-lock from a Binder thread. If we required the caller
660 * to pass 'this' by sp<> the temporary sp<> constructed could end up
661 * being the last reference and we might accidentally destroy the Layer
662 * from this binder thread.
663 */
saveBufferUpdate(int32_t layerId,uint32_t width,uint32_t height,uint64_t frameNumber)664 void SurfaceInterceptor::saveBufferUpdate(int32_t layerId, uint32_t width,
665 uint32_t height, uint64_t frameNumber)
666 {
667 if (!mEnabled) {
668 return;
669 }
670 ATRACE_CALL();
671 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
672 addBufferUpdateLocked(createTraceIncrementLocked(), layerId, width, height, frameNumber);
673 }
674
saveVSyncEvent(nsecs_t timestamp)675 void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
676 if (!mEnabled) {
677 return;
678 }
679 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
680 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp);
681 }
682
saveDisplayCreation(const DisplayDeviceState & info)683 void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) {
684 if (!mEnabled) {
685 return;
686 }
687 ATRACE_CALL();
688 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
689 addDisplayCreationLocked(createTraceIncrementLocked(), info);
690 }
691
saveDisplayDeletion(int32_t sequenceId)692 void SurfaceInterceptor::saveDisplayDeletion(int32_t sequenceId) {
693 if (!mEnabled) {
694 return;
695 }
696 ATRACE_CALL();
697 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
698 addDisplayDeletionLocked(createTraceIncrementLocked(), sequenceId);
699 }
700
savePowerModeUpdate(int32_t sequenceId,int32_t mode)701 void SurfaceInterceptor::savePowerModeUpdate(int32_t sequenceId, int32_t mode) {
702 if (!mEnabled) {
703 return;
704 }
705 ATRACE_CALL();
706 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
707 addPowerModeUpdateLocked(createTraceIncrementLocked(), sequenceId, mode);
708 }
709
710 } // namespace impl
711 } // namespace android
712
713 // TODO(b/129481165): remove the #pragma below and fix conversion issues
714 #pragma clang diagnostic pop // ignored "-Wconversion"
715