Vsync与app、surfaceFlinger关系(1)

app要进行更新，必须先要请求一个vsync,等到下个vsync信号来的时候进行界面的更新。
一、首先先看一下app请求vsync。
我们熟知的TextView.setText 或者ImageView.setImageBitmap,最后都要执行invalidate申请重绘,最后会通过ViewParent递归到ViewRootImpl的invalidate。Choreographer.postCallback进行vsync信号的申请。最终胡通过IDisplayEventConnection.cpp 的requestNextVsync，调用到服务端EventThread的requestNextVsync();
流程图如下：

18.png

流程比较简单，最终就是调用了一个 mChoreographer.postCallback

frameworks/base/core/java/android/view/ViewRootImpl.java
      @UnsupportedAppUsage
      void scheduleTraversals() {
          if (!mTraversalScheduled) {
              mTraversalScheduled = true;
              mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); @1
              mChoreographer.postCallback(
                      Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null); @2
              notifyRendererOfFramePending();
              pokeDrawLockIfNeeded();
          }
      }

@1 设置同步栅栏，拦截同步消息
@2 来请求请求vnsc垂直同步信号，

二、Choreograhper接下来的流程如下图：

19.png

看下几个重要方法
1、
scheduleFrameLocked可以被调用多次，但是mFrameScheduled保证下一个vsync到来之前，不会有新的请求发出，多余的scheduleFrameLocked调用被无效化

frameworks/base/core/java/android/view/Choreographer.java
private void scheduleFrameLocked(long now) {
    if (!mFrameScheduled) {   
        mFrameScheduled = true;
......
        if (ScrollOptimizer.shouldUseVsync(USE_VSYNC)) {
        ......
            if (isRunningOnLooperThreadLocked()) {
                scheduleVsyncLocked();
            } else {
                // 设置此message为异步消息，因为之前已经设置了同步屏障，所以异步消息会优先执行。
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtFrontOfQueue(msg);
            }
        }  
    }
}

2、
最终要的就是最后一步，在IDisplayEventConnection.cpp中的requestNextVsync方法

framworks/native/libs/gui/IDisplayEventConnection.cpp
      void requestNextVsync() override {
          callRemoteAsync<decltype(&IDisplayEventConnection::requestNextVsync)>(
                  Tag::REQUEST_NEXT_VSYNC);
      }
  };

这块CallRemoteAsync,异步binder调用到服务端，会执行服务端的onTransact方法，这个过程是夸进程的。

status_t BnDisplayEventConnection::onTransact(uint32_t code, const Parcel& data, Parcel* reply,
                                                uint32_t flags) {
      if (code < IBinder::FIRST_CALL_TRANSACTION || code > static_cast<uint32_t>(Tag::LAST)) {
          return BBinder::onTransact(code, data, reply, flags);
      }
      auto tag = static_cast<Tag>(code);
      switch (tag) {
          case Tag::STEAL_RECEIVE_CHANNEL:
              return callLocal(data, reply, &IDisplayEventConnection::stealReceiveChannel);
          case Tag::SET_VSYNC_RATE:
              return callLocal(data, reply, &IDisplayEventConnection::setVsyncRate);
          case Tag::REQUEST_NEXT_VSYNC: @1
              return callLocalAsync(data, reply, &IDisplayEventConnection::requestNextVsync);
      }
  }

在@1处会调用到 EventThreadConnection的 requestNextVsync。

21.png

很明显，BpDisplayEventConnection 的requestNextVsync 会binder调用到BnDisplayEventConnection的requestNextVsync。也就是夸进程，从app进程到surfaceFlinger进程。

看一下各自的位置
frameworks/native/libs/gui/DisplayEventReceiver.cpp

Client端：

class BpDisplayEventConnection : public SafeBpInterface<IDisplayEventConnection> {
......
}  在frameworks/native/libs/gui/IDisplayEventConnection.cpp 中

server端：

class EventThreadConnection : public BnDisplayEventConnection {
.....
}  在frameworks/native/services/surfaceflinger/scheduler/eventThread.h 中

class BnDisplayEventConnection : public SafeBnInterface<IDisplayEventConnection> {
......
}  在frameworks/native/include/gui/IDisplayEventConnection.h

三、接下来看下服务端(EventThreadConnection)的requestNextVsync

void EventThreadConnection::requestNextVsync() {
      ATRACE_NAME("requestNextVsync");
      mEventThread->requestNextVsync(this);
  }

会调用EventThread的requestNextVsync

void EventThread::requestNextVsync(const sp<EventThreadConnection>& connection) {
      if (connection->resyncCallback) {
          connection->resyncCallback();
      }
  
      std::lock_guard<std::mutex> lock(mMutex);  
  
      if (connection->vsyncRequest == VSyncRequest::None) {   
          connection->vsyncRequest = VSyncRequest::Single;
          mCondition.notify_all();   @1
      }
  }

因为 threadMain中的循环在EventThread的构造方法中已经启动，此时@1出的notify_call就会唤醒其 mConditioni.wait(lock),进入下一次循环，这时候就会执行 mVSyncSource->setVsyncEnable(true);

State nextState;
          if (mVSyncState && vsyncRequested) {
              nextState = mVSyncState->synthetic ? State::SyntheticVSync : State::VSync;
          } else {
              ALOGW_IF(!mVSyncState, "Ignoring VSYNC request while display is disconnected");
              nextState = State::Idle;
          }


          if (mState != nextState) {
              if (mState == State::VSync) {
                  mVSyncSource->setVSyncEnabled(false);
              } else if (nextState == State::VSync) {
                  mVSyncSource->setVSyncEnabled(true);    @2
              }
              mState = nextState;
          }

          if (event) {
              continue;
          }
  
          // Wait for event or client registration/request.
          if (mState == State::Idle) {
              mCondition.wait(lock);   @3
          } else {
              // Generate a fake VSYNC after a long timeout in case the driver stalls. When the
              // display is off, keep feeding clients at 60 Hz.
......

@3处就会等待下一次requestVsync信号过来进行唤醒，会进行下一次循环，经过一系列的操作，会执行 mVSyncSource->setVSyncEnabled(true);

frameworks/native/services/surfaceflinger/scheduler/DispSyncSource.cpp
void DispSyncSource::setVsyncEnabled(bool enable){
std::lock_gurad lock(mVsyncMutex);
If(enable){   @4
    status_t err = mDispSync->addEventlistener(mName,mPhaseOffset,static_cast<DispSync::Callback*>(this),mLastCallbackTime); @1
If(err != No_ERROE){
    ALOGE(“error registering vsync callback: %s (%d)”,strerror(-err),err);
}
}else{
   status_t err = mDispSync->removeEventlistener(mName,mPhaseOffset,static_cast<DispSync::Callback*>(this),mLastCallbackTime);
If(err != No_ERROE){
    ALOGE(“error unregistering vsync callback: %s (%d)”,strerror(-err),err);
}
  If(mDolphinCheck){
If(mDolphinCheck(mName)){
  status_t err = mDispSync->addEventlistener(mName,mPhaseOffset,static_cast<DispSync::Callback*>(this),mLastCallbackTime);
If(err != No_ERROE){
    ALOGE(“error registering vsync callback: %s (%d)”,strerror(-err),err);
}

}
}
}
mEnable = enable
}

在@4处 enable 为true的时候，会执行mDispSync->addEventListener注册一个vsync监听

system/native/services/surfaceflinger/scheduler/DispSync.cpp

    status_t addEventListener(const char* name, nsecs_t phase, DispSync::Callback* callback,
                              nsecs_t lastCallbackTime) {
        if (mTraceDetailedInfo) ATRACE_CALL();
        Mutex::Autolock lock(mMutex);

        for (size_t i = 0; i < mEventListeners.size(); i++) {
            if (mEventListeners[i].mCallback == callback) {
                return BAD_VALUE;
            }
        }

        EventListener listener;
        listener.mName = name;
        listener.mPhase = phase;
        listener.mCallback = callback;

        // We want to allow the firstmost future event to fire without
        // allowing any past events to fire. To do this extrapolate from
        // mReferenceTime the most recent hardware vsync, and pin the
        // last event time there.
        const nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        if (mPeriod != 0) {
            const nsecs_t baseTime = now - mReferenceTime;
            const nsecs_t numPeriodsSinceReference = baseTime / mPeriod;
            const nsecs_t predictedReference = mReferenceTime + numPeriodsSinceReference * mPeriod;
            const nsecs_t phaseCorrection = mPhase + listener.mPhase;
            const nsecs_t predictedLastEventTime = predictedReference + phaseCorrection;
            if (predictedLastEventTime >= now) {
                // Make sure that the last event time does not exceed the current time.
                // If it would, then back the last event time by a period.
                listener.mLastEventTime = predictedLastEventTime - mPeriod;
            } else {
                listener.mLastEventTime = predictedLastEventTime;
            }
        } else {
            listener.mLastEventTime = now + mPhase - mWakeupLatency;
        }

        if (lastCallbackTime <= 0) {
            // If there is no prior callback time, try to infer one based on the
            // logical last event time.
            listener.mLastCallbackTime = listener.mLastEventTime + mWakeupLatency;
        } else {
            listener.mLastCallbackTime = lastCallbackTime;
        }

        mEventListeners.push_back(listener);@1

        mCond.signal();

        return NO_ERROR;
}

传进来的参数name, phase, callback, lastCallbackTime 都会赋值给一个EventListener对象，然后@1处 存入一个vector类型的集合。这样app 的 vsync信号就算注册好了。