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