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 #ifndef TREEINFO_H 17 #define TREEINFO_H 18 19 #include "utils/Macros.h" 20 21 #include <utils/Timers.h> 22 23 #include <string> 24 25 namespace android { 26 namespace uirenderer { 27 28 namespace renderthread { 29 class CanvasContext; 30 } 31 32 class DamageAccumulator; 33 class LayerUpdateQueue; 34 class OpenGLRenderer; 35 class RenderNode; 36 class RenderState; 37 38 class ErrorHandler { 39 public: 40 virtual void onError(const std::string& message) = 0; 41 protected: ~ErrorHandler()42 ~ErrorHandler() {} 43 }; 44 45 class TreeObserver { 46 public: 47 // Called when a RenderNode's parent count hits 0. 48 // Due to the unordered nature of tree pushes, once prepareTree 49 // is finished it is possible that the node was "resurrected" and has 50 // a non-zero parent count. onMaybeRemovedFromTree(RenderNode * node)51 virtual void onMaybeRemovedFromTree(RenderNode* node) {} 52 protected: ~TreeObserver()53 ~TreeObserver() {} 54 }; 55 56 // This would be a struct, but we want to PREVENT_COPY_AND_ASSIGN 57 class TreeInfo { 58 PREVENT_COPY_AND_ASSIGN(TreeInfo); 59 public: 60 enum TraversalMode { 61 // The full monty - sync, push, run animators, etc... Used by DrawFrameTask 62 // May only be used if both the UI thread and RT thread are blocked on the 63 // prepare 64 MODE_FULL, 65 // Run only what can be done safely on RT thread. Currently this only means 66 // animators, but potentially things like SurfaceTexture updates 67 // could be handled by this as well if there are no listeners 68 MODE_RT_ONLY, 69 }; 70 TreeInfo(TraversalMode mode,renderthread::CanvasContext & canvasContext)71 TreeInfo(TraversalMode mode, renderthread::CanvasContext& canvasContext) 72 : mode(mode) 73 , prepareTextures(mode == MODE_FULL) 74 , canvasContext(canvasContext) 75 {} 76 77 TraversalMode mode; 78 // TODO: Remove this? Currently this is used to signal to stop preparing 79 // textures if we run out of cache space. 80 bool prepareTextures; 81 renderthread::CanvasContext& canvasContext; 82 // TODO: buildLayer uses this to suppress running any animations, but this 83 // should probably be refactored somehow. The reason this is done is 84 // because buildLayer is not setup for injecting the animationHook, as well 85 // as this being otherwise wasted work as all the animators will be 86 // re-evaluated when the frame is actually drawn 87 bool runAnimations = true; 88 89 // Must not be null during actual usage 90 DamageAccumulator* damageAccumulator = nullptr; 91 92 #if HWUI_NEW_OPS 93 LayerUpdateQueue* layerUpdateQueue = nullptr; 94 #else 95 // The renderer that will be drawing the next frame. Use this to push any 96 // layer updates or similar. May be NULL. 97 OpenGLRenderer* renderer = nullptr; 98 #endif 99 ErrorHandler* errorHandler = nullptr; 100 101 // Optional, may be nullptr. Used to allow things to observe interesting 102 // tree state changes 103 TreeObserver* observer = nullptr; 104 105 int32_t windowInsetLeft = 0; 106 int32_t windowInsetTop = 0; 107 bool updateWindowPositions = false; 108 109 struct Out { 110 bool hasFunctors = false; 111 // This is only updated if evaluateAnimations is true 112 bool hasAnimations = false; 113 // This is set to true if there is an animation that RenderThread cannot 114 // animate itself, such as if hasFunctors is true 115 // This is only set if hasAnimations is true 116 bool requiresUiRedraw = false; 117 // This is set to true if draw() can be called this frame 118 // false means that we must delay until the next vsync pulse as frame 119 // production is outrunning consumption 120 // NOTE that if this is false CanvasContext will set either requiresUiRedraw 121 // *OR* will post itself for the next vsync automatically, use this 122 // only to avoid calling draw() 123 bool canDrawThisFrame = true; 124 } out; 125 126 // TODO: Damage calculations 127 }; 128 129 } /* namespace uirenderer */ 130 } /* namespace android */ 131 132 #endif /* TREEINFO_H */ 133