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#undef LOG_TAG 17#define LOG_TAG "SurfaceInterceptor" 18#define ATRACE_TAG ATRACE_TAG_GRAPHICS 19 20#include "Layer.h" 21#include "SurfaceFlinger.h" 22#include "SurfaceInterceptor.h" 23 24#include <fstream> 25 26#include <android-base/file.h> 27#include <log/log.h> 28#include <utils/Trace.h> 29 30namespace android { 31 32// ---------------------------------------------------------------------------- 33 34SurfaceInterceptor::SurfaceInterceptor(SurfaceFlinger* flinger) 35 : mFlinger(flinger) 36{ 37} 38 39void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers, 40 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays) 41{ 42 if (mEnabled) { 43 return; 44 } 45 ATRACE_CALL(); 46 mEnabled = true; 47 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 48 saveExistingDisplaysLocked(displays); 49 saveExistingSurfacesLocked(layers); 50} 51 52void SurfaceInterceptor::disable() { 53 if (!mEnabled) { 54 return; 55 } 56 ATRACE_CALL(); 57 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 58 mEnabled = false; 59 status_t err(writeProtoFileLocked()); 60 ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied"); 61 ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields"); 62 mTrace.Clear(); 63} 64 65bool SurfaceInterceptor::isEnabled() { 66 return mEnabled; 67} 68 69void SurfaceInterceptor::saveExistingDisplaysLocked( 70 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays) 71{ 72 // Caveat: The initial snapshot does not capture the power mode of the existing displays 73 ATRACE_CALL(); 74 for (size_t i = 0 ; i < displays.size() ; i++) { 75 addDisplayCreationLocked(createTraceIncrementLocked(), displays[i]); 76 addInitialDisplayStateLocked(createTraceIncrementLocked(), displays[i]); 77 } 78} 79 80void SurfaceInterceptor::saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers) { 81 ATRACE_CALL(); 82 for (const auto& l : layers) { 83 l->traverseInZOrder(LayerVector::StateSet::Drawing, [this](Layer* layer) { 84 addSurfaceCreationLocked(createTraceIncrementLocked(), layer); 85 addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer); 86 }); 87 } 88} 89 90void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment, 91 const sp<const Layer>& layer) 92{ 93 Transaction* transaction(increment->mutable_transaction()); 94 transaction->set_synchronous(layer->mTransactionFlags & BnSurfaceComposer::eSynchronous); 95 transaction->set_animation(layer->mTransactionFlags & BnSurfaceComposer::eAnimation); 96 97 const int32_t layerId(getLayerId(layer)); 98 addPositionLocked(transaction, layerId, layer->mCurrentState.active.transform.tx(), 99 layer->mCurrentState.active.transform.ty()); 100 addDepthLocked(transaction, layerId, layer->mCurrentState.z); 101 addAlphaLocked(transaction, layerId, layer->mCurrentState.alpha); 102 addTransparentRegionLocked(transaction, layerId, layer->mCurrentState.activeTransparentRegion); 103 addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack); 104 addCropLocked(transaction, layerId, layer->mCurrentState.crop); 105 if (layer->mCurrentState.barrierLayer != nullptr) { 106 addDeferTransactionLocked(transaction, layerId, layer->mCurrentState.barrierLayer.promote(), 107 layer->mCurrentState.frameNumber); 108 } 109 addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop); 110 addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode()); 111 addFlagsLocked(transaction, layerId, layer->mCurrentState.flags); 112} 113 114void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment, 115 const DisplayDeviceState& display) 116{ 117 Transaction* transaction(increment->mutable_transaction()); 118 transaction->set_synchronous(false); 119 transaction->set_animation(false); 120 121 addDisplaySurfaceLocked(transaction, display.displayId, display.surface); 122 addDisplayLayerStackLocked(transaction, display.displayId, display.layerStack); 123 addDisplaySizeLocked(transaction, display.displayId, display.width, display.height); 124 addDisplayProjectionLocked(transaction, display.displayId, display.orientation, 125 display.viewport, display.frame); 126} 127 128status_t SurfaceInterceptor::writeProtoFileLocked() { 129 ATRACE_CALL(); 130 std::string output; 131 132 if (!mTrace.IsInitialized()) { 133 return NOT_ENOUGH_DATA; 134 } 135 if (!mTrace.SerializeToString(&output)) { 136 return PERMISSION_DENIED; 137 } 138 if (!android::base::WriteStringToFile(output, mOutputFileName, true)) { 139 return PERMISSION_DENIED; 140 } 141 142 return NO_ERROR; 143} 144 145const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) { 146 const sp<const IBinder>& handle(weakHandle.promote()); 147 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get())); 148 const sp<const Layer> layer(layerHandle->owner.promote()); 149 // layer could be a nullptr at this point 150 return layer; 151} 152 153const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) { 154 return layer->getName().string(); 155} 156 157int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) { 158 return layer->sequence; 159} 160 161Increment* SurfaceInterceptor::createTraceIncrementLocked() { 162 Increment* increment(mTrace.add_increment()); 163 increment->set_time_stamp(systemTime()); 164 return increment; 165} 166 167SurfaceChange* SurfaceInterceptor::createSurfaceChangeLocked(Transaction* transaction, 168 int32_t layerId) 169{ 170 SurfaceChange* change(transaction->add_surface_change()); 171 change->set_id(layerId); 172 return change; 173} 174 175DisplayChange* SurfaceInterceptor::createDisplayChangeLocked(Transaction* transaction, 176 int32_t displayId) 177{ 178 DisplayChange* dispChange(transaction->add_display_change()); 179 dispChange->set_id(displayId); 180 return dispChange; 181} 182 183void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) { 184 protoRect->set_left(rect.left); 185 protoRect->set_top(rect.top); 186 protoRect->set_right(rect.right); 187 protoRect->set_bottom(rect.bottom); 188} 189 190void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId, 191 float x, float y) 192{ 193 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 194 PositionChange* posChange(change->mutable_position()); 195 posChange->set_x(x); 196 posChange->set_y(y); 197} 198 199void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId, 200 uint32_t z) 201{ 202 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 203 LayerChange* depthChange(change->mutable_layer()); 204 depthChange->set_layer(z); 205} 206 207void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w, 208 uint32_t h) 209{ 210 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 211 SizeChange* sizeChange(change->mutable_size()); 212 sizeChange->set_w(w); 213 sizeChange->set_h(h); 214} 215 216void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId, 217 float alpha) 218{ 219 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 220 AlphaChange* alphaChange(change->mutable_alpha()); 221 alphaChange->set_alpha(alpha); 222} 223 224void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId, 225 const layer_state_t::matrix22_t& matrix) 226{ 227 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 228 MatrixChange* matrixChange(change->mutable_matrix()); 229 matrixChange->set_dsdx(matrix.dsdx); 230 matrixChange->set_dtdx(matrix.dtdx); 231 matrixChange->set_dsdy(matrix.dsdy); 232 matrixChange->set_dtdy(matrix.dtdy); 233} 234 235void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction, 236 int32_t layerId, const Region& transRegion) 237{ 238 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 239 TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint()); 240 241 for (const auto& rect : transRegion) { 242 Rectangle* protoRect(transparentChange->add_region()); 243 setProtoRectLocked(protoRect, rect); 244 } 245} 246 247void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, 248 uint8_t flags) 249{ 250 // There can be multiple flags changed 251 if (flags & layer_state_t::eLayerHidden) { 252 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 253 HiddenFlagChange* flagChange(change->mutable_hidden_flag()); 254 flagChange->set_hidden_flag(true); 255 } 256 if (flags & layer_state_t::eLayerOpaque) { 257 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 258 OpaqueFlagChange* flagChange(change->mutable_opaque_flag()); 259 flagChange->set_opaque_flag(true); 260 } 261 if (flags & layer_state_t::eLayerSecure) { 262 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 263 SecureFlagChange* flagChange(change->mutable_secure_flag()); 264 flagChange->set_secure_flag(true); 265 } 266} 267 268void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId, 269 uint32_t layerStack) 270{ 271 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 272 LayerStackChange* layerStackChange(change->mutable_layer_stack()); 273 layerStackChange->set_layer_stack(layerStack); 274} 275 276void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId, 277 const Rect& rect) 278{ 279 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 280 CropChange* cropChange(change->mutable_crop()); 281 Rectangle* protoRect(cropChange->mutable_rectangle()); 282 setProtoRectLocked(protoRect, rect); 283} 284 285void SurfaceInterceptor::addFinalCropLocked(Transaction* transaction, int32_t layerId, 286 const Rect& rect) 287{ 288 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 289 FinalCropChange* finalCropChange(change->mutable_final_crop()); 290 Rectangle* protoRect(finalCropChange->mutable_rectangle()); 291 setProtoRectLocked(protoRect, rect); 292} 293 294void SurfaceInterceptor::addDeferTransactionLocked(Transaction* transaction, int32_t layerId, 295 const sp<const Layer>& layer, uint64_t frameNumber) 296{ 297 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 298 if (layer == nullptr) { 299 ALOGE("An existing layer could not be retrieved with the handle" 300 " for the deferred transaction"); 301 return; 302 } 303 DeferredTransactionChange* deferTransaction(change->mutable_deferred_transaction()); 304 deferTransaction->set_layer_id(getLayerId(layer)); 305 deferTransaction->set_frame_number(frameNumber); 306} 307 308void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction, 309 int32_t layerId, int32_t overrideScalingMode) 310{ 311 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId)); 312 OverrideScalingModeChange* overrideChange(change->mutable_override_scaling_mode()); 313 overrideChange->set_override_scaling_mode(overrideScalingMode); 314} 315 316void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction, 317 const layer_state_t& state) 318{ 319 const sp<const Layer> layer(getLayer(state.surface)); 320 if (layer == nullptr) { 321 ALOGE("An existing layer could not be retrieved with the surface " 322 "from the layer_state_t surface in the update transaction"); 323 return; 324 } 325 326 const int32_t layerId(getLayerId(layer)); 327 328 if (state.what & layer_state_t::ePositionChanged) { 329 addPositionLocked(transaction, layerId, state.x, state.y); 330 } 331 if (state.what & layer_state_t::eLayerChanged) { 332 addDepthLocked(transaction, layerId, state.z); 333 } 334 if (state.what & layer_state_t::eSizeChanged) { 335 addSizeLocked(transaction, layerId, state.w, state.h); 336 } 337 if (state.what & layer_state_t::eAlphaChanged) { 338 addAlphaLocked(transaction, layerId, state.alpha); 339 } 340 if (state.what & layer_state_t::eMatrixChanged) { 341 addMatrixLocked(transaction, layerId, state.matrix); 342 } 343 if (state.what & layer_state_t::eTransparentRegionChanged) { 344 addTransparentRegionLocked(transaction, layerId, state.transparentRegion); 345 } 346 if (state.what & layer_state_t::eFlagsChanged) { 347 addFlagsLocked(transaction, layerId, state.flags); 348 } 349 if (state.what & layer_state_t::eLayerStackChanged) { 350 addLayerStackLocked(transaction, layerId, state.layerStack); 351 } 352 if (state.what & layer_state_t::eCropChanged) { 353 addCropLocked(transaction, layerId, state.crop); 354 } 355 if (state.what & layer_state_t::eDeferTransaction) { 356 sp<Layer> otherLayer = nullptr; 357 if (state.barrierHandle != nullptr) { 358 otherLayer = static_cast<Layer::Handle*>(state.barrierHandle.get())->owner.promote(); 359 } else if (state.barrierGbp != nullptr) { 360 auto const& gbp = state.barrierGbp; 361 if (mFlinger->authenticateSurfaceTextureLocked(gbp)) { 362 otherLayer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer(); 363 } else { 364 ALOGE("Attempt to defer transaction to to an unrecognized GraphicBufferProducer"); 365 } 366 } 367 addDeferTransactionLocked(transaction, layerId, otherLayer, state.frameNumber); 368 } 369 if (state.what & layer_state_t::eFinalCropChanged) { 370 addFinalCropLocked(transaction, layerId, state.finalCrop); 371 } 372 if (state.what & layer_state_t::eOverrideScalingModeChanged) { 373 addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode); 374 } 375} 376 377void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction, 378 const DisplayState& state, int32_t displayId) 379{ 380 if (state.what & DisplayState::eSurfaceChanged) { 381 addDisplaySurfaceLocked(transaction, displayId, state.surface); 382 } 383 if (state.what & DisplayState::eLayerStackChanged) { 384 addDisplayLayerStackLocked(transaction, displayId, state.layerStack); 385 } 386 if (state.what & DisplayState::eDisplaySizeChanged) { 387 addDisplaySizeLocked(transaction, displayId, state.width, state.height); 388 } 389 if (state.what & DisplayState::eDisplayProjectionChanged) { 390 addDisplayProjectionLocked(transaction, displayId, state.orientation, state.viewport, 391 state.frame); 392 } 393} 394 395void SurfaceInterceptor::addTransactionLocked(Increment* increment, 396 const Vector<ComposerState>& stateUpdates, 397 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays, 398 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags) 399{ 400 Transaction* transaction(increment->mutable_transaction()); 401 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous); 402 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation); 403 for (const auto& compState: stateUpdates) { 404 addSurfaceChangesLocked(transaction, compState.state); 405 } 406 for (const auto& disp: changedDisplays) { 407 ssize_t dpyIdx = displays.indexOfKey(disp.token); 408 if (dpyIdx >= 0) { 409 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx)); 410 addDisplayChangesLocked(transaction, disp, dispState.displayId); 411 } 412 } 413} 414 415void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment, 416 const sp<const Layer>& layer) 417{ 418 SurfaceCreation* creation(increment->mutable_surface_creation()); 419 creation->set_id(getLayerId(layer)); 420 creation->set_name(getLayerName(layer)); 421 creation->set_w(layer->mCurrentState.active.w); 422 creation->set_h(layer->mCurrentState.active.h); 423} 424 425void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment, 426 const sp<const Layer>& layer) 427{ 428 SurfaceDeletion* deletion(increment->mutable_surface_deletion()); 429 deletion->set_id(getLayerId(layer)); 430} 431 432void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, const sp<const Layer>& layer, 433 uint32_t width, uint32_t height, uint64_t frameNumber) 434{ 435 BufferUpdate* update(increment->mutable_buffer_update()); 436 update->set_id(getLayerId(layer)); 437 update->set_w(width); 438 update->set_h(height); 439 update->set_frame_number(frameNumber); 440} 441 442void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) { 443 VSyncEvent* event(increment->mutable_vsync_event()); 444 event->set_when(timestamp); 445} 446 447void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t displayId, 448 const sp<const IGraphicBufferProducer>& surface) 449{ 450 if (surface == nullptr) { 451 return; 452 } 453 uint64_t bufferQueueId = 0; 454 status_t err(surface->getUniqueId(&bufferQueueId)); 455 if (err == NO_ERROR) { 456 DisplayChange* dispChange(createDisplayChangeLocked(transaction, displayId)); 457 DispSurfaceChange* surfaceChange(dispChange->mutable_surface()); 458 surfaceChange->set_buffer_queue_id(bufferQueueId); 459 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string()); 460 } 461 else { 462 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)", 463 strerror(-err)); 464 } 465} 466 467void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction, 468 int32_t displayId, uint32_t layerStack) 469{ 470 DisplayChange* dispChange(createDisplayChangeLocked(transaction, displayId)); 471 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack()); 472 layerStackChange->set_layer_stack(layerStack); 473} 474 475void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t displayId, 476 uint32_t w, uint32_t h) 477{ 478 DisplayChange* dispChange(createDisplayChangeLocked(transaction, displayId)); 479 SizeChange* sizeChange(dispChange->mutable_size()); 480 sizeChange->set_w(w); 481 sizeChange->set_h(h); 482} 483 484void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction, 485 int32_t displayId, int32_t orientation, const Rect& viewport, const Rect& frame) 486{ 487 DisplayChange* dispChange(createDisplayChangeLocked(transaction, displayId)); 488 ProjectionChange* projectionChange(dispChange->mutable_projection()); 489 projectionChange->set_orientation(orientation); 490 Rectangle* viewportRect(projectionChange->mutable_viewport()); 491 setProtoRectLocked(viewportRect, viewport); 492 Rectangle* frameRect(projectionChange->mutable_frame()); 493 setProtoRectLocked(frameRect, frame); 494} 495 496void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment, 497 const DisplayDeviceState& info) 498{ 499 DisplayCreation* creation(increment->mutable_display_creation()); 500 creation->set_id(info.displayId); 501 creation->set_name(info.displayName); 502 creation->set_type(info.type); 503 creation->set_is_secure(info.isSecure); 504} 505 506void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t displayId) { 507 DisplayDeletion* deletion(increment->mutable_display_deletion()); 508 deletion->set_id(displayId); 509} 510 511void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t displayId, 512 int32_t mode) 513{ 514 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update()); 515 powerModeUpdate->set_id(displayId); 516 powerModeUpdate->set_mode(mode); 517} 518 519void SurfaceInterceptor::saveTransaction(const Vector<ComposerState>& stateUpdates, 520 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays, 521 const Vector<DisplayState>& changedDisplays, uint32_t flags) 522{ 523 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) { 524 return; 525 } 526 ATRACE_CALL(); 527 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 528 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays, 529 flags); 530} 531 532void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) { 533 if (!mEnabled || layer == nullptr) { 534 return; 535 } 536 ATRACE_CALL(); 537 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 538 addSurfaceCreationLocked(createTraceIncrementLocked(), layer); 539} 540 541void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) { 542 if (!mEnabled || layer == nullptr) { 543 return; 544 } 545 ATRACE_CALL(); 546 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 547 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer); 548} 549 550void SurfaceInterceptor::saveBufferUpdate(const sp<const Layer>& layer, uint32_t width, 551 uint32_t height, uint64_t frameNumber) 552{ 553 if (!mEnabled || layer == nullptr) { 554 return; 555 } 556 ATRACE_CALL(); 557 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 558 addBufferUpdateLocked(createTraceIncrementLocked(), layer, width, height, frameNumber); 559} 560 561void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) { 562 if (!mEnabled) { 563 return; 564 } 565 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 566 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp); 567} 568 569void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) { 570 if (!mEnabled) { 571 return; 572 } 573 ATRACE_CALL(); 574 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 575 addDisplayCreationLocked(createTraceIncrementLocked(), info); 576} 577 578void SurfaceInterceptor::saveDisplayDeletion(int32_t displayId) { 579 if (!mEnabled) { 580 return; 581 } 582 ATRACE_CALL(); 583 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 584 addDisplayDeletionLocked(createTraceIncrementLocked(), displayId); 585} 586 587void SurfaceInterceptor::savePowerModeUpdate(int32_t displayId, int32_t mode) { 588 if (!mEnabled) { 589 return; 590 } 591 ATRACE_CALL(); 592 std::lock_guard<std::mutex> protoGuard(mTraceMutex); 593 addPowerModeUpdateLocked(createTraceIncrementLocked(), displayId, mode); 594} 595 596 597} // namespace android 598