libs/hwui/renderthread/RenderProxy.h

   1 /*
   2  * Copyright (C) 2013 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 #ifndef RENDERPROXY_H_
  18 #define RENDERPROXY_H_
  19
  20 #include "RenderTask.h"
  21
  22 #include <cutils/compiler.h>
  23 #include <EGL/egl.h>
  24 #include <SkBitmap.h>
  25 #include <utils/Condition.h>
  26 #include <utils/Functor.h>
  27 #include <utils/Mutex.h>
  28 #include <utils/Timers.h>
  29 #include <utils/StrongPointer.h>
  30
  31 #include "../Caches.h"
  32 #include "../FrameMetricsObserver.h"
  33 #include "../IContextFactory.h"
  34 #include "CanvasContext.h"
  35 #include "DrawFrameTask.h"
  36
  37 namespace android {
  38 namespace uirenderer {
  39
  40 class DeferredLayerUpdater;
  41 class RenderNode;
  42 class DisplayList;
  43 class Layer;
  44 class Rect;
  45 class TreeObserver;
  46
  47 namespace renderthread {
  48
  49 class ErrorChannel;
  50 class RenderThread;
  51 class RenderProxyBridge;
  52
  53 namespace DumpFlags {
  54     enum {
  55         FrameStats = 1 << 0,
  56         Reset      = 1 << 1,
  57         JankStats  = 1 << 2,
  58     };
  59 };
  60
  61 /*
  62  * RenderProxy is strictly single threaded. All methods must be invoked on the owning
  63  * thread. It is important to note that RenderProxy may be deleted while it has
  64  * tasks post()'d as a result. Therefore any RenderTask that is post()'d must not
  65  * reference RenderProxy or any of its fields. The exception here is that postAndWait()
  66  * references RenderProxy fields. This is safe as RenderProxy cannot
  67  * be deleted if it is blocked inside a call.
  68  */
  69 class ANDROID_API RenderProxy {
  70 public:
  71     ANDROID_API RenderProxy(bool translucent, RenderNode* rootNode, IContextFactory* contextFactory);
  72     ANDROID_API virtual ~RenderProxy();
  73
  74     // Won't take effect until next EGLSurface creation
  75     ANDROID_API void setSwapBehavior(SwapBehavior swapBehavior);
  76     ANDROID_API bool loadSystemProperties();
  77     ANDROID_API void setName(const char* name);
  78
  79     ANDROID_API void initialize(const sp<Surface>& surface);
  80     ANDROID_API void updateSurface(const sp<Surface>& surface);
  81     ANDROID_API bool pauseSurface(const sp<Surface>& surface);
  82     ANDROID_API void setStopped(bool stopped);
  83     ANDROID_API void setup(int width, int height, float lightRadius,
  84             uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
  85     ANDROID_API void setLightCenter(const Vector3& lightCenter);
  86     ANDROID_API void setOpaque(bool opaque);
  87     ANDROID_API int64_t* frameInfo();
  88     ANDROID_API int syncAndDrawFrame(TreeObserver* observer);
  89     ANDROID_API void destroy(TreeObserver* observer);
  90
  91     ANDROID_API static void invokeFunctor(Functor* functor, bool waitForCompletion);
  92
  93     ANDROID_API void runWithGlContext(RenderTask* task);
  94
  95     ANDROID_API DeferredLayerUpdater* createTextureLayer();
  96     ANDROID_API void buildLayer(RenderNode* node, TreeObserver* observer);
  97     ANDROID_API bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap& bitmap);
  98     ANDROID_API void pushLayerUpdate(DeferredLayerUpdater* layer);
  99     ANDROID_API void cancelLayerUpdate(DeferredLayerUpdater* layer);
 100     ANDROID_API void detachSurfaceTexture(DeferredLayerUpdater* layer);
 101
 102     ANDROID_API void destroyHardwareResources(TreeObserver* observer);
 103     ANDROID_API static void trimMemory(int level);
 104     ANDROID_API static void overrideProperty(const char* name, const char* value);
 105
 106     ANDROID_API void fence();
 107     ANDROID_API static void staticFence();
 108     ANDROID_API void stopDrawing();
 109     ANDROID_API void notifyFramePending();
 110
 111     ANDROID_API void dumpProfileInfo(int fd, int dumpFlags);
 112     // Not exported, only used for testing
 113     void resetProfileInfo();
 114     ANDROID_API static void dumpGraphicsMemory(int fd);
 115
 116     ANDROID_API void setTextureAtlas(const sp<GraphicBuffer>& buffer, int64_t* map, size_t size);
 117     ANDROID_API void setProcessStatsBuffer(int fd);
 118
 119     ANDROID_API void serializeDisplayListTree();
 120
 121     ANDROID_API void addRenderNode(RenderNode* node, bool placeFront);
 122     ANDROID_API void removeRenderNode(RenderNode* node);
 123     ANDROID_API void drawRenderNode(RenderNode* node);
 124     ANDROID_API void setContentDrawBounds(int left, int top, int right, int bottom);
 125
 126     ANDROID_API void addFrameMetricsObserver(FrameMetricsObserver* observer);
 127     ANDROID_API void removeFrameMetricsObserver(FrameMetricsObserver* observer);
 128     ANDROID_API long getDroppedFrameReportCount();
 129
 130     ANDROID_API static int copySurfaceInto(sp<Surface>& surface, SkBitmap* bitmap);
 131
 132 private:
 133     RenderThread& mRenderThread;
 134     CanvasContext* mContext;
 135
 136     DrawFrameTask mDrawFrameTask;
 137
 138     Mutex mSyncMutex;
 139     Condition mSyncCondition;
 140
 141     void destroyContext();
 142
 143     void post(RenderTask* task);
 144     void* postAndWait(MethodInvokeRenderTask* task);
 145
 146     static void* staticPostAndWait(MethodInvokeRenderTask* task);
 147
 148     // Friend class to help with bridging
 149     friend class RenderProxyBridge;
 150 };
 151
 152 } /* namespace renderthread */
 153 } /* namespace uirenderer */
 154 } /* namespace android */
 155 #endif /* RENDERPROXY_H_ */