Android SurfaceFlinger服务（三） ----- 本地图层Layer创建

在上一篇文章中，主要分析了Surface的创建过程，对于Layer图层的创建并没有深入跟踪分析。这篇文章将分析Layer图层的创建，并分析handle gbp这两个变量的来源。

在SurfaceFlinger中会根据flags的值创建不同的layer。这里主要以创建普通layer为例进行分析。

status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
        const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
    // initialize the surfaces
    switch (format) {
    case PIXEL_FORMAT_TRANSPARENT:
    case PIXEL_FORMAT_TRANSLUCENT:
        format = PIXEL_FORMAT_RGBA_8888;
        break;
    case PIXEL_FORMAT_OPAQUE:
        format = PIXEL_FORMAT_RGBX_8888;
        break;
    }

    *outLayer = new Layer(this, client, name, w, h, flags);
    status_t err = (*outLayer)->setBuffers(w, h, format, flags);
    if (err == NO_ERROR) {
        *handle = (*outLayer)->getHandle();
        *gbp = (*outLayer)->getProducer();
    }

    ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
    return err;
}

• 创建一个Layer对象outLayer
• 调用Layer对象的getHandle()方法赋值给handle
• 调用Layer对象的getProducer()方法赋值给gbp

感觉快到源头了，在来看看Layer类的onFirstRef方法

void Layer::onFirstRef() {
    // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
    sp<IGraphicBufferProducer> producer;
    sp<IGraphicBufferConsumer> consumer;
    BufferQueue::createBufferQueue(&producer, &consumer);
    mProducer = new MonitoredProducer(producer, mFlinger);
    mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName);
    mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
    mSurfaceFlingerConsumer->setContentsChangedListener(this);
    mSurfaceFlingerConsumer->setName(mName);

#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
#warning "disabling triple buffering"
    mSurfaceFlingerConsumer->setDefaultMaxBufferCount(2);
#else
    mSurfaceFlingerConsumer->setDefaultMaxBufferCount(3);
#endif

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

• 调用BufferQueue::createBufferQueue()方法创建图像缓冲区队列
• 创建产生者对象MonitoredProducer，并赋值给mProducer
• 创建消费者对象SurfaceFlingerConsumer，并赋值给mSurfaceFlingerConsumer

在来看看Layer的getHandle方法

sp<IBinder> Layer::getHandle() {        
    Mutex::Autolock _l(mLock);

    LOG_ALWAYS_FATAL_IF(mHasSurface,
            "Layer::getHandle() has already been called");

    mHasSurface = true;

    /* 
     * The layer handle is just a BBinder object passed to the client
     * (remote process) -- we don't keep any reference on our side such that
     * the dtor is called when the remote side let go of its reference.
     * 
     * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
     * this layer when the handle is destroyed.
     */

    class Handle : public BBinder, public LayerCleaner {
        wp<const Layer> mOwner;
    public:
        Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
            : LayerCleaner(flinger, layer), mOwner(layer) {
        }
    }; 

    return new Handle(mFlinger, this);
}

• 最终返回一个Handle类的binder对象，不知道有什么用

小结，当客户端创建Surface的时候，SurfaceFlinger服务端为会之创建对应的图层Layer。并且把Layer的图像缓冲区的生产者接口赋值给Surface对象的成员变量mGraphicBufferProducer。最后，应用层得到了Layer的生产者接口生产数据，在看看Layer的消费者监听函数。

前面，在Layer的onFirstRef函数中创建了类SurfaceFlingerConsumer对象。该类间接继承了ConsumerBase消费者基类，所以它要调用setFrameAvailableListener方法去设置监听器。看看setContentsChangedListener方法的实现

void SurfaceFlingerConsumer::setContentsChangedListener(
        const wp<ContentsChangedListener>& listener) {
    setFrameAvailableListener(listener);
    Mutex::Autolock lock(mMutex);
    mContentsChangedListener = listener;
}

• 正如上说所说，调用setFrameAvailableListener设置监听器listener
• 传进来的参数listener为Layer引用，最终调用Layer的onFrameAvailable函数

void Layer::onFrameAvailable(const BufferItem& item) {
    // Add this buffer from our internal queue tracker
    { // Autolock scope
        Mutex::Autolock lock(mQueueItemLock);                                                                                                                                                

        // Reset the frame number tracker when we receive the first buffer after                                                                                                             
        // a frame number reset
        if (item.mFrameNumber == 1) {
            mLastFrameNumberReceived = 0;        
        }

        // Ensure that callbacks are handled in order
        while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
            status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,                                                                                                               
                    ms2ns(500));
            if (result != NO_ERROR) {   
                ALOGE("[%s] Timed out waiting on callback", mName.string());                                                                                                                 
            }
        }

        mQueueItems.push_back(item);
        android_atomic_inc(&mQueuedFrames);                                                                                                                                                  

        // Wake up any pending callbacks
        mLastFrameNumberReceived = item.mFrameNumber;
        mQueueItemCondition.broadcast();
    }  

    mFlinger->signalLayerUpdate();
}

• 调用SurfaceFlinger的signalLayerUpdate发送图层更新信息,看看SurfaceFlinger的处理
• SurfaceFlinger中调用mEventQueue.invalidate()发送消息，处理函数handleMessageInvalidate

bool SurfaceFlinger::handleMessageInvalidate() {
    ATRACE_CALL();
    return handlePageFlip();
}

• 通过handlePageFlip把有效缓冲区切换到前台，等待SurfaceFlinger合成显示