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