【Android-Surface】的繪製流程

WindowManagerService.java

public int relayoutWindow(Session session, ...){
  ...
  result = createSurfaceControl(outSurface, result, win, winAnimator);
  ...
}

private int createSurfaceControl(Surface outSurface, WindowStateAnimator winAnimator, ...) {
  WindowSurfaceController surfaceController;
  try {
    surfaceController = winAnimator.createSurfaceLocked(win.mAttrs.type, win.mOwnerUid);
  } 
  if (surfaceController != null) {
    surfaceController.getSurface(outSurface);
  } 
  ...
}

WindowSurfaceController createSurfaceLocked(int windowType, int ownerUid) {
  ...
  mSurfaceController = new WindowSurfaceController(mSession.mSurfaceSession, ...);
  ...
  return mSurfaceController;
}

public WindowSurfaceController(SurfaceSession s, ...) {
  ....
  mSurfaceControl = new SurfaceControlWithBackground(s, ...);
  ....
}

public SurfaceControlWithBackground(SurfaceSession s, ...){
  ...
  mBackgroundControl = new SurfaceControl(s, ...);
  ...
}

public SurfaceControl(SurfaceSession session, ...){
  ...
  mNativeObject = nativeCreate(session, ...);
  ...
}

//Native層的處理：
static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj, ...) {
    ScopedUtfChars name(env, nameStr);
    //根據sessionObj取一個SurfaceComposerClient對象
    sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));
    //調用這個對象的createSuface創建SuraceControl
    sp<SurfaceControl> surface = client->createSurface(...);
    
    return reinterpret_cast<jlong>(surface.get());
}

sp<SurfaceControl> SurfaceComposerClient::createSurface(...){
  sp<SurfaceControl> sur;
  if (mStatus == NO_ERROR) {
    //獲取GBP
    sp<IGraphicBufferProducer> gbp;
    //mClient是一個Client它在onFirstRef中創建，見下面展開
    status_t err = mClient->createSurface(&gbp, ...);
    if (err == NO_ERROR) {
      //創建SurfaceControl
      sur = new SurfaceControl(this, handle, gbp);
    }
  }
  ..
  return sur;
}

void SurfaceComposerClient::onFirstRef() {
  //獲得一個SurfaceComposer對象，它是SurfaceFlinger的代理對象
  sp<ISurfaceComposer> sm(ComposerService::getComposerService());
  if (sm != 0) {
    //主注意這個rootProducer，它表示根GBP。而mParent是在構造函數中賦值的，見下面展開
    //第一次調用的時候爲空
    auto rootProducer = mParent.promote();
    sp<ISurfaceComposerClient> conn;
    //如果rootProducer 存在，則調用createScopedConnection()，裏面將把rootProducer作爲GBP
    //如果rootProducer不存在，則調用createConnection()，第一次調用的時候走此分支
    //最終得到一個ISurfaceComposerClient對象
    conn = (rootProducer != nullptr) ? sm->createScopedConnection(rootProducer): sm->createConnection();
    if (conn != 0) {
      //給mClient賦值
      mClient = conn;
    }
  }
}

//Client.cpp:

status_t Client::createSurface(sp<IGraphicBufferProducer>* gbp, ...)
{
  //定義了一個自帶處理函數的消息，這個消息最終會在MessageQueue的Looper中被處理
  class MessageCreateLayer : public MessageBase {
        SurfaceFlinger* flinger;
        sp<IGraphicBufferProducer>* gbp;
        sp<Layer>* parent;
    public:
        MessageCreateLayer(SurfaceFlinger* flinger, sp<IGraphicBufferProducer>* gbp,sp<Layer>* parent,...)
            : flinger(flinger), gbp(gbp), parent(parent) {
        }
        status_t getResult() const { return result; }
        //消息的處理函數
        virtual bool handler() {
          //調用SurfaceFlinger的createLayer函數
            result = flinger->createLayer(gbp, parent, ...);
            return true;
        }
    };
  //封裝了一個消息丟到了SufaceFlinger的mEventQueue消息隊列中
  sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
            name, this, w, h, format, flags, handle,
            windowType, ownerUid, gbp, &parent);
  //post到mEventQueue並等待結果返回
  mFlinger->postMessageSync(msg);
}

status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg, ...) {
  //把消息丟到MessageQueue中
  status_t res = mEventQueue.postMessage(msg);
  if (res == NO_ERROR) {
    //等待結果
    msg->wait();
  }
  return res;
}

status_t MessageQueue::postMessage(const sp<MessageBase>& messageHandler, nsecs_t relTime){
    const Message dummyMessage;
    if (relTime > 0) {
        mLooper->sendMessageDelayed(relTime, messageHandler, dummyMessage);
    } else {
        mLooper->sendMessage(messageHandler, dummyMessage);
    }
    return NO_ERROR;
}

//SurfaceFlinger最終調用

status_t SurfaceFlinger::createLayer(sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent, ...)
{
  sp<Layer> layer;
  switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
    case ISurfaceComposerClient::eFXSurfaceNormal:
      //創建一個Layer對象
      result = createNormalLayer(gbp, &layer,...);
      break;
  }
  //把這個對象加到parent中
  result = addClientLayer(*gbp, layer, *parent,...);
  return result;
}

status_t SurfaceFlinger::createNormalLayer(sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
  *outLayer = new Layer(this, client, name, w, h, flags);
  status_t err = (*outLayer)->setBuffers(w, h, format, flags);
  if (err == NO_ERROR) {
    //千呼萬喚纔出來，終於找到了GBP的來源：是Layer的Producer，這意味着這個GBP的消息者可能在Layer中可以找到線索
    *gbp = (*outLayer)->getProducer();
  }
  return err;
}


status_t SurfaceFlinger::addClientLayer(const sp<IGraphicBufferProducer>& gbp, const sp<Layer>& lbc, const sp<Layer>& parent)
{
  {
    if (parent == nullptr) {
        mCurrentState.layersSortedByZ.add(lbc);
    } else {
        parent->addChild(lbc);
    }
    //這個很重要：登記這個gbp，Surface只接受登記過的生產者生產的Buffer
    mGraphicBufferProducerList.add(IInterface::asBinder(gbp));
    mNumLayers++;
  }
  ...
  return NO_ERROR;
}

Layer中的GBP是如何創建的

void Layer::onFirstRef() {
    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
    sp<IGraphicBufferProducer> producer;
    sp<IGraphicBufferConsumer> consumer;
    //創建一對生產<->消費者，生產端留給自己用，
    BufferQueue::createBufferQueue(&producer, &consumer, true);
    //這層包裝有一個重要作用是：在MonitoredProducer的釋構函數中發消息給SurfaceFlinger把自己從監控列表中移除
    mProducer = new MonitoredProducer(producer, mFlinger, this);
    //mSurfaceFlingerConsumer是GLConsumer的子類對象，是真正的消費者
    //當view繪製完成後Layer的onFrameAvailable將被調用，Layer通知SurfaceFlinger
    //SurfaceFlinger根據Surface的層疊關係決定哪些層的層些區域要渲染
    //然後再通過Layer通知GLConsumer來真正消費————讀取buffer的數據並執行渲染
    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName, this);
    mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
    mSurfaceFlingerConsumer->setContentsChangedListener(this);
    mSurfaceFlingerConsumer->setName(mName);

    if (mFlinger->isLayerTripleBufferingDisabled()) {
      
      mProducer->setMaxDequeuedBufferCount(2);
    }

    const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice());
    updateTransformHint(hw);
}

sp<IGraphicBufferProducer> Layer::getProducer() const {
    return mProducer;
}