Choreographer應用最廣泛的是其postCallback()方法可以提供在vsync信號來到時進行回調，本篇的就是為了說明其原理。

• Choreographer的初始化

 private final Looper mLooper;
 private final FrameHandler mHandler;
 private final FrameDisplayEventReceiver mDisplayEventReceiver;

private Choreographer(Looper looper, int vsyncSource){
  mLooper = looper;
  mHandler = new FrameHandler(looper);
  nDisplayEventReceiver = USE_VSYNC? new FrameDisplayEventReceiver(looper, vsyncSource):null;
  mLastFrameTimeNanos = Long.MIN_VALUE;
  mFrameIntervalNanos = (long)(1000000000/getRefreshRate());
  mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
  for(int i=0;i<=CALLBACK_LAST;i++){
    mCallbackQueuesi[i] = new CallbackQueue();
  }
  setFPSDivisor(SystemProperties.getInt(ThreadRender.DEBUG_FPS_DIVISOR,1));
}

其他的都沒有什么內容，這里的關鍵是這個FrameDisplayEventReceiver;我們目前在這里分析的是ViewRootImpl中的Choreographer，所以認為這里的looper為MainLooper(不影響整體分析，在Choreographer中可以看到有兩個ThreadLocal提供線程單例)。

• FrameDisplayEventReceiver繼承自DisplayEventReceiver，重寫了onVsync與run

//DisplayEventReceiver.java
public DisplayEventReceiver(Looper looper, int vsyncSource){
  mMessageQueue = looper.getQueue();
  mReceiverPtr=nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue, vsyncSource);
}

//messageQueue可以認為是主線程的MessageQueue，
//該方法的native實現(xiàn)在../framework/base/core/jni/android_view_DisplayEventReceiver.cpp
private static native long nativeInit(WeakReference<DisplayEventReceiver> receiver, MessageQueue messageQueue, int vsyncSource);

//android_view_DisplayEventReceiver.cpp
static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverObj, jobject messageQueueObj){
  //Java層的MessageQueue還是依托native層的MessageQueue去實現(xiàn)的
  sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
  //創(chuàng)建一個NativeDisplayEventReceiver對象
  sp<NativeDisplayEventReceiver> receiver = new NativeDisplayEventReceiver(env, receiverObj, messageQueue);
  status_t status = receiver->initialize();
  receiver->incStrong(gDisplayEventReceiverClassInfo.clazz);
  return reinterpret_cast<jnit>(receiver.get());
}


class NativeDisplayEventReceiver : public LooperCallback{
  ...
  private:
    ...
    DisplayEventReceiver mReceiver;
}

//保存成員變量
NativeDisplayEventReceiver::NativeDisplayEventReceiver(JNIEnv* env, jobject receiverObj, const sp<MessageQueue>& messageQueue):
  mReceiverObjGlobal(env->NewGlobalRef(receiverObj)), mMessageQueue(mMessageQueue), mWaitingForVsync(false){}


status_t NativeDisplayEventReceiver::initialize(){
  status_t result = mReceiver.initCheck();
  int rc = mMessageQueue->getLooper()->addFd(mReceiver.getFd(), 0, ALOOPER_EVENT_INPUT, this, NULL);
}

在這里，mReceiver是DisplayEventReceiver對象

• DisplayEventReceiver.cpp

DisplayEventReceiver::DisplayEventReceiver(){
  sp<ISurfaceComposer> sf(ComposerService::getComposerService());
  if(sf != NULL){
    mEventConnection = sf->createDisplayEventConnection();
    if(mEventConnection != NULL){
      mDataChannel = mEventConnection->getDataChannel();
    }
  }
}

//定義在DisplayEventReciver.h
sp<IDisplayEventConnection> mEventConnection;
sp<BitTube> mDataChannel;

從另外一篇SurfaceFlinger可以找到這里的mDataChannel為一個BitTube對象，內部為管道。并且在其創(chuàng)建的時候會注冊在EventThread中，在接受到vsync信號后，會在EventThread中進行寫入注冊的BitTube的管道中。

int DisplayEventReceiver::getFd() const {
  return mDataChannel->getFd(); 
}

• 結論

聯(lián)系Handler的阻塞分析，在底層收到vsync信號后，EventThread會往注冊的BitTube中寫入數(shù)據(jù)，而這里Choreographer在底層正是將這個BitTube注冊到MessageQueue的Looper，于是收到一個vsync后，對應的MessageQueue就會被喚醒，從而進行下一步。

如何利用BitTube的

//EventThread.cpp
void EventThread::Connection::onFirstRef(){
  mEventThread->registerDisplayConnection(this);
}

status_t EventThread::registerDisplayEventConnection(const sp<EventThread::Connection>& connection){
  mDisplayEventConnections.add(connection);
}

bool EventThread::threadLoop(){
  ...
  status_t err = conn->postEvent(event);
  ...
}

status_t EventThread::Connection::postEvent(const DisplayEventReceiver::Event& event){
  ssize_t size = DisplayEventReceiver::sendEvent(mChannel, &event, 1);
}

//DisplayEventReceiver.cpp
ssize_t DisplayEventReceiver::sendEvents(const sp<BitTube>& dataChannel, Event const* events, size_t count){
  return BitTube::sendObject(dataChannel,events,count);
}

//BitTube.cpp
ssize_t BitTube::sendObjects(const sp<BitTube>& tube, void const* events, size_t count, size_t objSize){
  ...
  const char* vaddr = reinterpret_cast<const char*>(events) + objSize*i;
  ssize_t size = tube->write(vaddr, objsize);
  ... 
}

ssize_t BitTube::write(void const* vaddr, size_t size){
  ...
  len = ::send(mSendFd, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
  ...
}

同時在Looper中的添加的fd為mReceiveFd，與mSendFd相對應，此時Looper就會被喚醒了。

因此每次收到vsync信號，對應的Looper中的MessageQueue都會在阻塞中被喚醒(如果被阻塞的話)。

//Choreographer
public void postCallback(int callbackType, Runnable action, Object token){
  postCallbackDelayed(callbackType, action, token, 0);
}

public void postCallbackDelayed(int callbackType, Runnable action, Object token, long delayMillis){
  postCallbackDelayInternal(callbackType, action, token, delayMillis);
}

private void postCallbackDelayInternal(int callbackType, Object action, Object token, long delayMillis){
  synchronized(mLock){
    final long now = SystemClock.uptimeMillis();
    final long dueTime = now + delayMillis;
     mCallbackQueues[callbackType].addCallbackLocked(dueTime,action,token);

  if(dueTime <= now){
    scheduleFrameLocked(now);
  }else{
    Message msg=mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
    msg.arg1=callbackType;
    msg.setAsynchronous(true);
    mHandler.sendMessageAtTime(msg,dueTime);
  }
  }
}

//todo

好的學習