Home | History | Annotate | Download | only in renderthread 
      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 #include <utils/Vector.h>
     31 
     32 #include "../Caches.h"
     33 #include "../IContextFactory.h"
     34 #include "DrawFrameTask.h"
     35 
     36 namespace android {
     37 namespace uirenderer {
     38 
     39 class DeferredLayerUpdater;
     40 class RenderNode;
     41 class DisplayListData;
     42 class Layer;
     43 class Rect;
     44 
     45 namespace renderthread {
     46 
     47 class CanvasContext;
     48 class ErrorChannel;
     49 class RenderThread;
     50 class RenderProxyBridge;
     51 
     52 /*
     53  * RenderProxy is strictly single threaded. All methods must be invoked on the owning
     54  * thread. It is important to note that RenderProxy may be deleted while it has
     55  * tasks post()'d as a result. Therefore any RenderTask that is post()'d must not
     56  * reference RenderProxy or any of its fields. The exception here is that postAndWait()
     57  * references RenderProxy fields. This is safe as RenderProxy cannot
     58  * be deleted if it is blocked inside a call.
     59  */
     60 class ANDROID_API RenderProxy {
     61 public:
     62     ANDROID_API RenderProxy(bool translucent, RenderNode* rootNode, IContextFactory* contextFactory);
     63     ANDROID_API virtual ~RenderProxy();
     64 
     65     ANDROID_API void setFrameInterval(nsecs_t frameIntervalNanos);
     66     ANDROID_API bool loadSystemProperties();
     67 
     68     ANDROID_API bool initialize(const sp<ANativeWindow>& window);
     69     ANDROID_API void updateSurface(const sp<ANativeWindow>& window);
     70     ANDROID_API void pauseSurface(const sp<ANativeWindow>& window);
     71     ANDROID_API void setup(int width, int height, const Vector3& lightCenter, float lightRadius,
     72             uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
     73     ANDROID_API void setOpaque(bool opaque);
     74     ANDROID_API int syncAndDrawFrame(nsecs_t frameTimeNanos, nsecs_t recordDurationNanos,
     75             float density);
     76     ANDROID_API void destroy();
     77 
     78     ANDROID_API static void invokeFunctor(Functor* functor, bool waitForCompletion);
     79 
     80     ANDROID_API void runWithGlContext(RenderTask* task);
     81 
     82     static void enqueueDestroyLayer(Layer* layer);
     83     ANDROID_API DeferredLayerUpdater* createTextureLayer();
     84     ANDROID_API void buildLayer(RenderNode* node);
     85     ANDROID_API bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap);
     86     ANDROID_API void pushLayerUpdate(DeferredLayerUpdater* layer);
     87     ANDROID_API void cancelLayerUpdate(DeferredLayerUpdater* layer);
     88     ANDROID_API void detachSurfaceTexture(DeferredLayerUpdater* layer);
     89 
     90     ANDROID_API void destroyHardwareResources();
     91     ANDROID_API static void trimMemory(int level);
     92 
     93     ANDROID_API void fence();
     94     ANDROID_API void stopDrawing();
     95     ANDROID_API void notifyFramePending();
     96 
     97     ANDROID_API void dumpProfileInfo(int fd);
     98 
     99     ANDROID_API void setTextureAtlas(const sp<GraphicBuffer>& buffer, int64_t* map, size_t size);
    100 
    101 private:
    102     RenderThread& mRenderThread;
    103     CanvasContext* mContext;
    104 
    105     DrawFrameTask mDrawFrameTask;
    106 
    107     Mutex mSyncMutex;
    108     Condition mSyncCondition;
    109 
    110     void destroyContext();
    111 
    112     void post(RenderTask* task);
    113     void* postAndWait(MethodInvokeRenderTask* task);
    114 
    115     // Friend class to help with bridging
    116     friend class RenderProxyBridge;
    117 };
    118 
    119 } /* namespace renderthread */
    120 } /* namespace uirenderer */
    121 } /* namespace android */
    122 #endif /* RENDERPROXY_H_ */
    123