Android6.0 显示系统（二） SurfaceFlinger创建Surface

本文主要是介绍Android6.0 显示系统（二） SurfaceFlinger创建Surface，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

接上篇博客分析到SurfaceComposerClient中调用createSurface函数会最后调用到SurfaceFlinger的Client的createSurface函数。

我们来看下这个函数，其handle和gbp都是Binder对象，gbp就是图像缓冲区对象。这个handle对象的作用和前面介绍Activity中的token作用类似，也是利用Binder的唯一性为Surface生成一个唯一标识。

[cpp]  view plain  copy 
 status_t Client::createSurface(  
         const String8& name,  
         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,  
         sp<IBinder>* handle,  
         sp<IGraphicBufferProducer>* gbp)  
 {  
     /* 
      * createSurface must be called from the GL thread so that it can 
      * have access to the GL context. 
      */  
   
     class MessageCreateLayer : public MessageBase {  
         SurfaceFlinger* flinger;  
         Client* client;  
         sp<IBinder>* handle;  
         sp<IGraphicBufferProducer>* gbp;  
         status_t result;  
         const String8& name;  
         uint32_t w, h;  
         PixelFormat format;  
         uint32_t flags;  
     public:  
         MessageCreateLayer(SurfaceFlinger* flinger,  
                 const String8& name, Client* client,  
                 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,  
                 sp<IBinder>* handle,  
                 sp<IGraphicBufferProducer>* gbp)  
             : flinger(flinger), client(client),  
               handle(handle), gbp(gbp),  
               name(name), w(w), h(h), format(format), flags(flags) {  
         }  
         status_t getResult() const { return result; }  
         virtual bool handler() {  
             result = flinger->createLayer(name, client, w, h, format, flags,  
                     handle, gbp);  
             return true;  
         }  
     };  
   
     sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),  
             name, this, w, h, format, flags, handle, gbp);  
     mFlinger->postMessageSync(msg);  
     return static_cast<MessageCreateLayer*>( msg.get() )->getResult();  
 }  

这个函数中定义了一个消息类MessageCreateLayer，然后把它的对象通过postMessageSync方法发送出去，这个消息是以同步的方式发送，因此函数结束后可以直接返回结果。因此就直接到了handler函数，在这个函数中调用了SurfaceFlinger的createLayer函数。

一、创建Layer

这个函数会根据传进来的flags来创建普通的的Layer还是模糊的Layer。

[cpp]  view plain  copy 
 status_t SurfaceFlinger::createLayer(  
         const String8& name,  
         const sp<Client>& client,  
         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,  
         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)  
 {  
     if (int32_t(w|h) < 0) {  
         ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",  
                 int(w), int(h));  
         return BAD_VALUE;  
     }  
   
     status_t result = NO_ERROR;  
   
     sp<Layer> layer;  
   
     switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {  
         case ISurfaceComposerClient::eFXSurfaceNormal:  
             result = createNormalLayer(client,//普通的  
                     name, w, h, flags, format,  
                     handle, gbp, &layer);  
             break;  
         case ISurfaceComposerClient::eFXSurfaceDim://模糊的  
             result = createDimLayer(client,  
                     name, w, h, flags,  
                     handle, gbp, &layer);  
             break;  
         default:  
             result = BAD_VALUE;  
             break;  
     }  
   
     if (result != NO_ERROR) {  
         return result;  
     }  
   
     result = addClientLayer(client, *handle, *gbp, layer);  
     if (result != NO_ERROR) {  
         return result;  
     }  
   
     setTransactionFlags(eTransactionNeeded);  
     return result;  
 }  

我们先来看看创建普通的Layer，根据传入的format参数，选择不同格式。然后创建一个Layer，具体Layer我们后续介绍。然后获取handle和gbp。

[cpp]  view plain  copy 
 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);//创建一个Layer  
     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，这个比较简单，直接新建一个layerDim,然后获取handle和gbp。

[cpp]  view plain  copy 
 status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,  
         const String8& name, uint32_t w, uint32_t h, uint32_t flags,  
         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)  
 {  
     *outLayer = new LayerDim(this, client, name, w, h, flags);  
     *handle = (*outLayer)->getHandle();  
     *gbp = (*outLayer)->getProducer();  
     return NO_ERROR;  
 }  

二、获取handle

下面我们再来看handle的获取，只是新建一个Handle，而这个Handle只是一个Binder的实现，就是标识Surface的全局唯一性，没有什么实际的内容。

[cpp]  view plain  copy 
 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);  
 }  

三、gbp图像缓冲区

那么我们再来看看gbp的获取,就是Layer中mProducer成员变量。

[cpp]  view plain  copy 
 sp<IGraphicBufferProducer> Layer::getProducer() const {  
     return mProducer;  
 }  

而mProducer是在Layer的onFirstRef中赋值的，我们注意MonitoredProducer构造函数的一个参数producer，事实上MonitoredProducer只是一个代理类，真正的实现在这个producer参数。它是在BufferQueue::createBufferQueue中创造的。

[cpp]  view plain  copy 
 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);  
     ......  

这个producer就是BufferQueueProducer对象。

[cpp]  view plain  copy 
 void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,  
         sp<IGraphicBufferConsumer>* outConsumer,  
         const sp<IGraphicBufferAlloc>& allocator) {  
   
     sp<BufferQueueCore> core(new BufferQueueCore(allocator));  
     sp<IGraphicBufferProducer> producer(new BufferQueueProducer(core));  
     sp<IGraphicBufferConsumer> consumer(new BufferQueueConsumer(core));  
   
     *outProducer = producer;  
     *outConsumer = consumer;  
 }  