RenderThread.h revision 3b20251a355c88193c439f928a84ae69483fb488
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 RENDERTHREAD_H_ 18#define RENDERTHREAD_H_ 19 20#include "RenderTask.h" 21 22#include <memory> 23#include <set> 24 25#include <cutils/compiler.h> 26#include <utils/Looper.h> 27#include <utils/Mutex.h> 28#include <utils/Singleton.h> 29#include <utils/Thread.h> 30 31#include "TimeLord.h" 32 33namespace android { 34 35class DisplayEventReceiver; 36 37namespace uirenderer { 38 39class RenderState; 40 41namespace renderthread { 42 43class DispatchFrameCallbacks; 44class EglManager; 45class RenderProxy; 46 47class TaskQueue { 48public: 49 TaskQueue(); 50 51 RenderTask* next(); 52 void queue(RenderTask* task); 53 void queueAtFront(RenderTask* task); 54 RenderTask* peek(); 55 void remove(RenderTask* task); 56 57private: 58 RenderTask* mHead; 59 RenderTask* mTail; 60}; 61 62// Mimics android.view.Choreographer.FrameCallback 63class IFrameCallback { 64public: 65 virtual void doFrame() = 0; 66 67protected: 68 ~IFrameCallback() {} 69}; 70 71class ANDROID_API RenderThread : public Thread, protected Singleton<RenderThread> { 72public: 73 // RenderThread takes complete ownership of tasks that are queued 74 // and will delete them after they are run 75 ANDROID_API void queue(RenderTask* task); 76 ANDROID_API void queueAtFront(RenderTask* task); 77 void queueDelayed(RenderTask* task, int delayMs); 78 void remove(RenderTask* task); 79 80 // Mimics android.view.Choreographer 81 void postFrameCallback(IFrameCallback* callback); 82 void removeFrameCallback(IFrameCallback* callback); 83 // If the callback is currently registered, it will be pushed back until 84 // the next vsync. If it is not currently registered this does nothing. 85 void pushBackFrameCallback(IFrameCallback* callback); 86 87 TimeLord& timeLord() { return mTimeLord; } 88 RenderState& renderState() { return *mRenderState; } 89 EglManager& eglManager() { return *mEglManager; } 90 91protected: 92 virtual bool threadLoop(); 93 94private: 95 friend class Singleton<RenderThread>; 96 friend class DispatchFrameCallbacks; 97 friend class RenderProxy; 98 99 RenderThread(); 100 virtual ~RenderThread(); 101 102 void initThreadLocals(); 103 void initializeDisplayEventReceiver(); 104 static int displayEventReceiverCallback(int fd, int events, void* data); 105 void drainDisplayEventQueue(bool skipCallbacks = false); 106 void dispatchFrameCallbacks(); 107 void requestVsync(); 108 109 // Returns the next task to be run. If this returns NULL nextWakeup is set 110 // to the time to requery for the nextTask to run. mNextWakeup is also 111 // set to this time 112 RenderTask* nextTask(nsecs_t* nextWakeup); 113 114 sp<Looper> mLooper; 115 Mutex mLock; 116 117 nsecs_t mNextWakeup; 118 TaskQueue mQueue; 119 120 DisplayEventReceiver* mDisplayEventReceiver; 121 bool mVsyncRequested; 122 std::set<IFrameCallback*> mFrameCallbacks; 123 // We defer the actual registration of these callbacks until 124 // both mQueue *and* mDisplayEventReceiver have been drained off all 125 // immediate events. This makes sure that we catch the next vsync, not 126 // the previous one 127 std::set<IFrameCallback*> mPendingRegistrationFrameCallbacks; 128 bool mFrameCallbackTaskPending; 129 DispatchFrameCallbacks* mFrameCallbackTask; 130 131 TimeLord mTimeLord; 132 RenderState* mRenderState; 133 EglManager* mEglManager; 134}; 135 136} /* namespace renderthread */ 137} /* namespace uirenderer */ 138} /* namespace android */ 139#endif /* RENDERTHREAD_H_ */ 140