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
25namespace android {
26namespace uirenderer {
27
28namespace renderthread {
29class CanvasContext;
30}
31
32class DamageAccumulator;
33class LayerUpdateQueue;
34class OpenGLRenderer;
35class RenderNode;
36class RenderState;
37
38class ErrorHandler {
39public:
40    virtual void onError(const std::string& message) = 0;
41protected:
42    ~ErrorHandler() {}
43};
44
45class TreeObserver {
46public:
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) {}
52protected:
53    ~TreeObserver() {}
54};
55
56// This would be a struct, but we want to PREVENT_COPY_AND_ASSIGN
57class TreeInfo {
58    PREVENT_COPY_AND_ASSIGN(TreeInfo);
59public:
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
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