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 "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 RenderNode;
35 class RenderState;
36 
37 class ErrorHandler {
38 public:
39     virtual void onError(const std::string& message) = 0;
40 
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.
51     virtual void onMaybeRemovedFromTree(RenderNode* node) = 0;
52 
53 protected:
~TreeObserver()54     virtual ~TreeObserver() {}
55 };
56 
57 // This would be a struct, but we want to PREVENT_COPY_AND_ASSIGN
58 class TreeInfo {
59     PREVENT_COPY_AND_ASSIGN(TreeInfo);
60 
61 public:
62     enum TraversalMode {
63         // The full monty - sync, push, run animators, etc... Used by DrawFrameTask
64         // May only be used if both the UI thread and RT thread are blocked on the
65         // prepare
66         MODE_FULL,
67         // Run only what can be done safely on RT thread. Currently this only means
68         // animators, but potentially things like SurfaceTexture updates
69         // could be handled by this as well if there are no listeners
70         MODE_RT_ONLY,
71     };
72 
TreeInfo(TraversalMode mode,renderthread::CanvasContext & canvasContext)73     TreeInfo(TraversalMode mode, renderthread::CanvasContext& canvasContext)
74             : mode(mode), prepareTextures(mode == MODE_FULL), 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 
91     LayerUpdateQueue* layerUpdateQueue = nullptr;
92     ErrorHandler* errorHandler = nullptr;
93 
94     bool updateWindowPositions = false;
95 
96     struct Out {
97         bool hasFunctors = false;
98         // This is only updated if evaluateAnimations is true
99         bool hasAnimations = false;
100         // This is set to true if there is an animation that RenderThread cannot
101         // animate itself, such as if hasFunctors is true
102         // This is only set if hasAnimations is true
103         bool requiresUiRedraw = false;
104         // This is set to true if draw() can be called this frame
105         // false means that we must delay until the next vsync pulse as frame
106         // production is outrunning consumption
107         // NOTE that if this is false CanvasContext will set either requiresUiRedraw
108         // *OR* will post itself for the next vsync automatically, use this
109         // only to avoid calling draw()
110         bool canDrawThisFrame = true;
111         // Sentinel for animatedImageDelay meaning there is no need to post such
112         // a message.
113         static constexpr nsecs_t kNoAnimatedImageDelay = -1;
114         // This is used to post a message to redraw when it is time to draw the
115         // next frame of an AnimatedImageDrawable.
116         nsecs_t animatedImageDelay = kNoAnimatedImageDelay;
117     } out;
118 
119     // This flag helps to disable projection for receiver nodes that do not have any backward
120     // projected children.
121     bool hasBackwardProjectedNodes = false;
122     // TODO: Damage calculations
123 };
124 
125 } /* namespace uirenderer */
126 } /* namespace android */
127