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