CanvasContext.cpp revision b6c2624c8d9ee71d1c8d0aaf8082f92bb84b1418
1/* 2 * Copyright (C) 2014 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#include "CanvasContext.h" 18 19#include "AnimationContext.h" 20#include "Caches.h" 21#include "DeferredLayerUpdater.h" 22#include "EglManager.h" 23#include "LayerRenderer.h" 24#include "OpenGLRenderer.h" 25#include "Properties.h" 26#include "RenderThread.h" 27#include "renderstate/RenderState.h" 28#include "renderstate/Stencil.h" 29#include "protos/hwui.pb.h" 30 31#if HWUI_NEW_OPS 32#include "BakedOpRenderer.h" 33#include "OpReorderer.h" 34#endif 35 36#include <cutils/properties.h> 37#include <google/protobuf/io/zero_copy_stream_impl.h> 38#include <private/hwui/DrawGlInfo.h> 39#include <strings.h> 40 41#include <algorithm> 42#include <fcntl.h> 43#include <sys/stat.h> 44 45#define TRIM_MEMORY_COMPLETE 80 46#define TRIM_MEMORY_UI_HIDDEN 20 47 48#define ENABLE_RENDERNODE_SERIALIZATION false 49 50#define LOG_FRAMETIME_MMA 0 51 52#if LOG_FRAMETIME_MMA 53static float sBenchMma = 0; 54static int sFrameCount = 0; 55static const float NANOS_PER_MILLIS_F = 1000000.0f; 56#endif 57 58namespace android { 59namespace uirenderer { 60namespace renderthread { 61 62CanvasContext::CanvasContext(RenderThread& thread, bool translucent, 63 RenderNode* rootRenderNode, IContextFactory* contextFactory) 64 : mRenderThread(thread) 65 , mEglManager(thread.eglManager()) 66 , mOpaque(!translucent) 67 , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord())) 68 , mJankTracker(thread.timeLord().frameIntervalNanos()) 69 , mProfiler(mFrames) 70 , mContentDrawBounds(0, 0, 0, 0) { 71 mRenderNodes.emplace_back(rootRenderNode); 72 mRenderThread.renderState().registerCanvasContext(this); 73 mProfiler.setDensity(mRenderThread.mainDisplayInfo().density); 74} 75 76CanvasContext::~CanvasContext() { 77 destroy(); 78 mRenderThread.renderState().unregisterCanvasContext(this); 79} 80 81void CanvasContext::destroy() { 82 stopDrawing(); 83 setSurface(nullptr); 84 freePrefetechedLayers(); 85 destroyHardwareResources(); 86 mAnimationContext->destroy(); 87 if (mCanvas) { 88 delete mCanvas; 89 mCanvas = nullptr; 90 } 91} 92 93void CanvasContext::setSurface(ANativeWindow* window) { 94 ATRACE_CALL(); 95 96 mNativeWindow = window; 97 98 if (mEglSurface != EGL_NO_SURFACE) { 99 mEglManager.destroySurface(mEglSurface); 100 mEglSurface = EGL_NO_SURFACE; 101 } 102 103 if (window) { 104 mEglSurface = mEglManager.createSurface(window); 105 } 106 107 if (mEglSurface != EGL_NO_SURFACE) { 108 const bool preserveBuffer = (mSwapBehavior != kSwap_discardBuffer); 109 mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer); 110 mHaveNewSurface = true; 111 makeCurrent(); 112 } else { 113 mRenderThread.removeFrameCallback(this); 114 } 115} 116 117void CanvasContext::requireSurface() { 118 LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE, 119 "requireSurface() called but no surface set!"); 120 makeCurrent(); 121} 122 123void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) { 124 mSwapBehavior = swapBehavior; 125} 126 127bool CanvasContext::initialize(ANativeWindow* window) { 128 setSurface(window); 129#if !HWUI_NEW_OPS 130 if (mCanvas) return false; 131 mCanvas = new OpenGLRenderer(mRenderThread.renderState()); 132 mCanvas->initProperties(); 133#endif 134 return true; 135} 136 137void CanvasContext::updateSurface(ANativeWindow* window) { 138 setSurface(window); 139} 140 141bool CanvasContext::pauseSurface(ANativeWindow* window) { 142 return mRenderThread.removeFrameCallback(this); 143} 144 145// TODO: don't pass viewport size, it's automatic via EGL 146void CanvasContext::setup(int width, int height, float lightRadius, 147 uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) { 148 if (!mCanvas) return; 149 mCanvas->initLight(lightRadius, ambientShadowAlpha, spotShadowAlpha); 150} 151 152void CanvasContext::setLightCenter(const Vector3& lightCenter) { 153 if (!mCanvas) return; 154 mCanvas->setLightCenter(lightCenter); 155} 156 157void CanvasContext::setOpaque(bool opaque) { 158 mOpaque = opaque; 159} 160 161void CanvasContext::makeCurrent() { 162 // TODO: Figure out why this workaround is needed, see b/13913604 163 // In the meantime this matches the behavior of GLRenderer, so it is not a regression 164 EGLint error = 0; 165 mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface, &error); 166 if (error) { 167 setSurface(nullptr); 168 } 169} 170 171void CanvasContext::processLayerUpdate(DeferredLayerUpdater* layerUpdater) { 172#if !HWUI_NEW_OPS 173 bool success = layerUpdater->apply(); 174 LOG_ALWAYS_FATAL_IF(!success, "Failed to update layer!"); 175 if (layerUpdater->backingLayer()->deferredUpdateScheduled) { 176 mCanvas->pushLayerUpdate(layerUpdater->backingLayer()); 177 } 178#endif 179} 180 181static bool wasSkipped(FrameInfo* info) { 182 return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame); 183} 184 185void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, 186 int64_t syncQueued, RenderNode* target) { 187 mRenderThread.removeFrameCallback(this); 188 189 // If the previous frame was dropped we don't need to hold onto it, so 190 // just keep using the previous frame's structure instead 191 if (!wasSkipped(mCurrentFrameInfo)) { 192 mCurrentFrameInfo = &mFrames.next(); 193 } 194 mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo); 195 mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued; 196 mCurrentFrameInfo->markSyncStart(); 197 198 info.damageAccumulator = &mDamageAccumulator; 199 info.renderer = mCanvas; 200 info.canvasContext = this; 201 202 mAnimationContext->startFrame(info.mode); 203 for (const sp<RenderNode>& node : mRenderNodes) { 204 // Only the primary target node will be drawn full - all other nodes would get drawn in 205 // real time mode. In case of a window, the primary node is the window content and the other 206 // node(s) are non client / filler nodes. 207 info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY); 208 node->prepareTree(info); 209 } 210 mAnimationContext->runRemainingAnimations(info); 211 212 freePrefetechedLayers(); 213 214 if (CC_UNLIKELY(!mNativeWindow.get())) { 215 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 216 info.out.canDrawThisFrame = false; 217 return; 218 } 219 220 int runningBehind = 0; 221 // TODO: This query is moderately expensive, investigate adding some sort 222 // of fast-path based off when we last called eglSwapBuffers() as well as 223 // last vsync time. Or something. 224 mNativeWindow->query(mNativeWindow.get(), 225 NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind); 226 info.out.canDrawThisFrame = !runningBehind; 227 228 if (!info.out.canDrawThisFrame) { 229 mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 230 } 231 232 if (info.out.hasAnimations || !info.out.canDrawThisFrame) { 233 if (!info.out.requiresUiRedraw) { 234 // If animationsNeedsRedraw is set don't bother posting for an RT anim 235 // as we will just end up fighting the UI thread. 236 mRenderThread.postFrameCallback(this); 237 } 238 } 239} 240 241void CanvasContext::stopDrawing() { 242 mRenderThread.removeFrameCallback(this); 243} 244 245void CanvasContext::notifyFramePending() { 246 ATRACE_CALL(); 247 mRenderThread.pushBackFrameCallback(this); 248} 249 250void CanvasContext::draw() { 251#if !HWUI_NEW_OPS 252 LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE, 253 "drawRenderNode called on a context with no canvas or surface!"); 254#endif 255 256 SkRect dirty; 257 mDamageAccumulator.finish(&dirty); 258 259 // TODO: Re-enable after figuring out cause of b/22592975 260// if (dirty.isEmpty() && Properties::skipEmptyFrames) { 261// mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame); 262// return; 263// } 264 265 mCurrentFrameInfo->markIssueDrawCommandsStart(); 266 267 Frame frame = mEglManager.beginFrame(mEglSurface); 268 269 if (frame.width() != lastFrameWidth || frame.height() != lastFrameHeight) { 270 // can't rely on prior content of window if viewport size changes 271 dirty.setEmpty(); 272 lastFrameWidth = frame.width(); 273 lastFrameHeight = frame.height(); 274 } else if (mHaveNewSurface || frame.bufferAge() == 0) { 275 // New surface needs a full draw 276 dirty.setEmpty(); 277 } else { 278 if (!dirty.isEmpty() && !dirty.intersect(0, 0, frame.width(), frame.height())) { 279 ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", 280 SK_RECT_ARGS(dirty), frame.width(), frame.height()); 281 dirty.setEmpty(); 282 } 283 profiler().unionDirty(&dirty); 284 } 285 286 if (dirty.isEmpty()) { 287 dirty.set(0, 0, frame.width(), frame.height()); 288 } 289 290 // At this point dirty is the area of the screen to update. However, 291 // the area of the frame we need to repaint is potentially different, so 292 // stash the screen area for later 293 SkRect screenDirty(dirty); 294 295 // If the buffer age is 0 we do a full-screen repaint (handled above) 296 // If the buffer age is 1 the buffer contents are the same as they were 297 // last frame so there's nothing to union() against 298 // Therefore we only care about the > 1 case. 299 if (frame.bufferAge() > 1) { 300 if (frame.bufferAge() > (int) mDamageHistory.size()) { 301 // We don't have enough history to handle this old of a buffer 302 // Just do a full-draw 303 dirty.set(0, 0, frame.width(), frame.height()); 304 } else { 305 // At this point we haven't yet added the latest frame 306 // to the damage history (happens below) 307 // So we need to damage 308 for (int i = mDamageHistory.size() - 1; 309 i > ((int) mDamageHistory.size()) - frame.bufferAge(); i--) { 310 dirty.join(mDamageHistory[i]); 311 } 312 } 313 } 314 315 // Add the screen damage to the ring buffer. 316 mDamageHistory.next() = screenDirty; 317 318 mEglManager.damageFrame(frame, dirty); 319 320#if HWUI_NEW_OPS 321 OpReorderer reorderer; 322 reorderer.defer(dirty, frame.width(), frame.height(), mRenderNodes); 323 BakedOpRenderer::Info info(Caches::getInstance(), mRenderThread.renderState(), 324 frame.width(), frame.height(), mOpaque); 325 // TODO: profiler().draw(mCanvas); 326 reorderer.replayBakedOps<BakedOpRenderer>(info); 327 328 bool drew = info.didDraw; 329 330#else 331 mCanvas->prepareDirty(frame.width(), frame.height(), 332 dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque); 333 334 Rect outBounds; 335 // It there are multiple render nodes, they are laid out as follows: 336 // #0 - backdrop (content + caption) 337 // #1 - content (positioned at (0,0) and clipped to - its bounds mContentDrawBounds) 338 // #2 - additional overlay nodes 339 // Usually the backdrop cannot be seen since it will be entirely covered by the content. While 340 // resizing however it might become partially visible. The following render loop will crop the 341 // backdrop against the content and draw the remaining part of it. It will then draw the content 342 // cropped to the backdrop (since that indicates a shrinking of the window). 343 // 344 // Additional nodes will be drawn on top with no particular clipping semantics. 345 346 // The bounds of the backdrop against which the content should be clipped. 347 Rect backdropBounds = mContentDrawBounds; 348 // Usually the contents bounds should be mContentDrawBounds - however - we will 349 // move it towards the fixed edge to give it a more stable appearance (for the moment). 350 Rect contentBounds; 351 // If there is no content bounds we ignore the layering as stated above and start with 2. 352 int layer = (mContentDrawBounds.isEmpty() || mRenderNodes.size() == 1) ? 2 : 0; 353 // Draw all render nodes. Note that 354 for (const sp<RenderNode>& node : mRenderNodes) { 355 if (layer == 0) { // Backdrop. 356 // Draw the backdrop clipped to the inverse content bounds, but assume that the content 357 // was moved to the upper left corner. 358 const RenderProperties& properties = node->properties(); 359 Rect targetBounds(properties.getLeft(), properties.getTop(), 360 properties.getRight(), properties.getBottom()); 361 // Move the content bounds towards the fixed corner of the backdrop. 362 const int x = targetBounds.left; 363 const int y = targetBounds.top; 364 contentBounds.set(x, y, x + mContentDrawBounds.getWidth(), 365 y + mContentDrawBounds.getHeight()); 366 // Remember the intersection of the target bounds and the intersection bounds against 367 // which we have to crop the content. 368 backdropBounds.set(x, y, x + backdropBounds.getWidth(), y + backdropBounds.getHeight()); 369 backdropBounds.doIntersect(targetBounds); 370 // Check if we have to draw something on the left side ... 371 if (targetBounds.left < contentBounds.left) { 372 mCanvas->save(SkCanvas::kClip_SaveFlag); 373 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, 374 contentBounds.left, targetBounds.bottom, 375 SkRegion::kIntersect_Op)) { 376 mCanvas->drawRenderNode(node.get(), outBounds); 377 } 378 // Reduce the target area by the area we have just painted. 379 targetBounds.left = std::min(contentBounds.left, targetBounds.right); 380 mCanvas->restore(); 381 } 382 // ... or on the right side ... 383 if (targetBounds.right > contentBounds.right && 384 !targetBounds.isEmpty()) { 385 mCanvas->save(SkCanvas::kClip_SaveFlag); 386 if (mCanvas->clipRect(contentBounds.right, targetBounds.top, 387 targetBounds.right, targetBounds.bottom, 388 SkRegion::kIntersect_Op)) { 389 mCanvas->drawRenderNode(node.get(), outBounds); 390 } 391 // Reduce the target area by the area we have just painted. 392 targetBounds.right = std::max(targetBounds.left, contentBounds.right); 393 mCanvas->restore(); 394 } 395 // ... or at the top ... 396 if (targetBounds.top < contentBounds.top && 397 !targetBounds.isEmpty()) { 398 mCanvas->save(SkCanvas::kClip_SaveFlag); 399 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, targetBounds.right, 400 contentBounds.top, 401 SkRegion::kIntersect_Op)) { 402 mCanvas->drawRenderNode(node.get(), outBounds); 403 } 404 // Reduce the target area by the area we have just painted. 405 targetBounds.top = std::min(contentBounds.top, targetBounds.bottom); 406 mCanvas->restore(); 407 } 408 // ... or at the bottom. 409 if (targetBounds.bottom > contentBounds.bottom && 410 !targetBounds.isEmpty()) { 411 mCanvas->save(SkCanvas::kClip_SaveFlag); 412 if (mCanvas->clipRect(targetBounds.left, contentBounds.bottom, targetBounds.right, 413 targetBounds.bottom, SkRegion::kIntersect_Op)) { 414 mCanvas->drawRenderNode(node.get(), outBounds); 415 } 416 mCanvas->restore(); 417 } 418 } else if (layer == 1) { // Content 419 // It gets cropped against the bounds of the backdrop to stay inside. 420 mCanvas->save(SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag); 421 422 // We shift and clip the content to match its final location in the window. 423 const float left = mContentDrawBounds.left; 424 const float top = mContentDrawBounds.top; 425 const float dx = backdropBounds.left - left; 426 const float dy = backdropBounds.top - top; 427 const float width = backdropBounds.getWidth(); 428 const float height = backdropBounds.getHeight(); 429 430 mCanvas->translate(dx, dy); 431 if (mCanvas->clipRect(left, top, left + width, top + height, SkRegion::kIntersect_Op)) { 432 mCanvas->drawRenderNode(node.get(), outBounds); 433 } 434 mCanvas->restore(); 435 } else { // draw the rest on top at will! 436 mCanvas->drawRenderNode(node.get(), outBounds); 437 } 438 layer++; 439 } 440 441 profiler().draw(mCanvas); 442 443 bool drew = mCanvas->finish(); 444#endif 445 // Even if we decided to cancel the frame, from the perspective of jank 446 // metrics the frame was swapped at this point 447 mCurrentFrameInfo->markSwapBuffers(); 448 449 if (drew) { 450 if (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty))) { 451 setSurface(nullptr); 452 } 453 mHaveNewSurface = false; 454 } 455 456 // TODO: Use a fence for real completion? 457 mCurrentFrameInfo->markFrameCompleted(); 458 459#if LOG_FRAMETIME_MMA 460 float thisFrame = mCurrentFrameInfo->duration( 461 FrameInfoIndex::IssueDrawCommandsStart, 462 FrameInfoIndex::FrameCompleted) / NANOS_PER_MILLIS_F; 463 if (sFrameCount) { 464 sBenchMma = ((9 * sBenchMma) + thisFrame) / 10; 465 } else { 466 sBenchMma = thisFrame; 467 } 468 if (++sFrameCount == 10) { 469 sFrameCount = 1; 470 ALOGD("Average frame time: %.4f", sBenchMma); 471 } 472#endif 473 474 mJankTracker.addFrame(*mCurrentFrameInfo); 475 mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo); 476} 477 478// Called by choreographer to do an RT-driven animation 479void CanvasContext::doFrame() { 480 if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) { 481 return; 482 } 483 prepareAndDraw(nullptr); 484} 485 486void CanvasContext::prepareAndDraw(RenderNode* node) { 487 ATRACE_CALL(); 488 489 int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE]; 490 UiFrameInfoBuilder(frameInfo) 491 .addFlag(FrameInfoFlags::RTAnimation) 492 .setVsync(mRenderThread.timeLord().computeFrameTimeNanos(), 493 mRenderThread.timeLord().latestVsync()); 494 495 TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState()); 496 prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node); 497 if (info.out.canDrawThisFrame) { 498 draw(); 499 } 500} 501 502void CanvasContext::invokeFunctor(RenderThread& thread, Functor* functor) { 503 ATRACE_CALL(); 504 DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext; 505 if (thread.eglManager().hasEglContext()) { 506 mode = DrawGlInfo::kModeProcess; 507 } 508 509 thread.renderState().invokeFunctor(functor, mode, nullptr); 510} 511 512void CanvasContext::markLayerInUse(RenderNode* node) { 513 if (mPrefetechedLayers.erase(node)) { 514 node->decStrong(nullptr); 515 } 516} 517 518static void destroyPrefetechedNode(RenderNode* node) { 519 ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...", node->getName()); 520 node->destroyHardwareResources(); 521 node->decStrong(nullptr); 522} 523 524void CanvasContext::freePrefetechedLayers() { 525 if (mPrefetechedLayers.size()) { 526 std::for_each(mPrefetechedLayers.begin(), mPrefetechedLayers.end(), destroyPrefetechedNode); 527 mPrefetechedLayers.clear(); 528 } 529} 530 531void CanvasContext::buildLayer(RenderNode* node) { 532 ATRACE_CALL(); 533 if (!mEglManager.hasEglContext() || !mCanvas) { 534 return; 535 } 536 // buildLayer() will leave the tree in an unknown state, so we must stop drawing 537 stopDrawing(); 538 539 TreeInfo info(TreeInfo::MODE_FULL, mRenderThread.renderState()); 540 info.damageAccumulator = &mDamageAccumulator; 541 info.renderer = mCanvas; 542 info.runAnimations = false; 543 node->prepareTree(info); 544 SkRect ignore; 545 mDamageAccumulator.finish(&ignore); 546 // Tickle the GENERIC property on node to mark it as dirty for damaging 547 // purposes when the frame is actually drawn 548 node->setPropertyFieldsDirty(RenderNode::GENERIC); 549 550 mCanvas->markLayersAsBuildLayers(); 551 mCanvas->flushLayerUpdates(); 552 553 node->incStrong(nullptr); 554 mPrefetechedLayers.insert(node); 555} 556 557bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) { 558 layer->apply(); 559 return LayerRenderer::copyLayer(mRenderThread.renderState(), layer->backingLayer(), bitmap); 560} 561 562void CanvasContext::destroyHardwareResources() { 563 stopDrawing(); 564 if (mEglManager.hasEglContext()) { 565 freePrefetechedLayers(); 566 for (const sp<RenderNode>& node : mRenderNodes) { 567 node->destroyHardwareResources(); 568 } 569 Caches& caches = Caches::getInstance(); 570 // Make sure to release all the textures we were owning as there won't 571 // be another draw 572 caches.textureCache.resetMarkInUse(this); 573 caches.flush(Caches::FlushMode::Layers); 574 } 575} 576 577void CanvasContext::trimMemory(RenderThread& thread, int level) { 578 // No context means nothing to free 579 if (!thread.eglManager().hasEglContext()) return; 580 581 ATRACE_CALL(); 582 if (level >= TRIM_MEMORY_COMPLETE) { 583 Caches::getInstance().flush(Caches::FlushMode::Full); 584 thread.eglManager().destroy(); 585 } else if (level >= TRIM_MEMORY_UI_HIDDEN) { 586 Caches::getInstance().flush(Caches::FlushMode::Moderate); 587 } 588} 589 590void CanvasContext::runWithGlContext(RenderTask* task) { 591 LOG_ALWAYS_FATAL_IF(!mEglManager.hasEglContext(), 592 "GL context not initialized!"); 593 task->run(); 594} 595 596Layer* CanvasContext::createTextureLayer() { 597 requireSurface(); 598 return LayerRenderer::createTextureLayer(mRenderThread.renderState()); 599} 600 601void CanvasContext::setTextureAtlas(RenderThread& thread, 602 const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize) { 603 thread.eglManager().setTextureAtlas(buffer, map, mapSize); 604} 605 606void CanvasContext::dumpFrames(int fd) { 607 FILE* file = fdopen(fd, "a"); 608 fprintf(file, "\n\n---PROFILEDATA---\n"); 609 for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) { 610 fprintf(file, "%s", FrameInfoNames[i].c_str()); 611 fprintf(file, ","); 612 } 613 for (size_t i = 0; i < mFrames.size(); i++) { 614 FrameInfo& frame = mFrames[i]; 615 if (frame[FrameInfoIndex::SyncStart] == 0) { 616 continue; 617 } 618 fprintf(file, "\n"); 619 for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) { 620 fprintf(file, "%" PRId64 ",", frame[i]); 621 } 622 } 623 fprintf(file, "\n---PROFILEDATA---\n\n"); 624 fflush(file); 625} 626 627void CanvasContext::resetFrameStats() { 628 mFrames.clear(); 629 mRenderThread.jankTracker().reset(); 630} 631 632void CanvasContext::serializeDisplayListTree() { 633#if ENABLE_RENDERNODE_SERIALIZATION 634 using namespace google::protobuf::io; 635 char package[128]; 636 // Check whether tracing is enabled for this process. 637 FILE * file = fopen("/proc/self/cmdline", "r"); 638 if (file) { 639 if (!fgets(package, 128, file)) { 640 ALOGE("Error reading cmdline: %s (%d)", strerror(errno), errno); 641 fclose(file); 642 return; 643 } 644 fclose(file); 645 } else { 646 ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno), 647 errno); 648 return; 649 } 650 char path[1024]; 651 snprintf(path, 1024, "/data/data/%s/cache/rendertree_dump", package); 652 int fd = open(path, O_CREAT | O_WRONLY, S_IRWXU | S_IRGRP | S_IROTH); 653 if (fd == -1) { 654 ALOGD("Failed to open '%s'", path); 655 return; 656 } 657 proto::RenderNode tree; 658 // TODO: Streaming writes? 659 mRootRenderNode->copyTo(&tree); 660 std::string data = tree.SerializeAsString(); 661 write(fd, data.c_str(), data.length()); 662 close(fd); 663#endif 664} 665 666} /* namespace renderthread */ 667} /* namespace uirenderer */ 668} /* namespace android */ 669