在之前的课时中，编写了SurfaceTest.cpp测试程序，该课时我们通过这个简单的程序去了解SurfaceFlinger内部机制内部机制。我们再来回顾一下SurfaceTest的步骤，主要如下图所示： 
在上小节中，讲解了应用程序创建SurfaceFlinger客户端(client)，即获得服务，创建一个client的过程，我们来回顾一下。 1.获得SurfaceFlinger服务 2.调用服务的createConnection函数建立一个连接，即应用程序与SurfaceFlinger的联系 3.SurfaceFlinger中会创建一个client对象，在APP应用程序边，会获得一个代理类的对象，后续可以使用这个代理类创建surface。
该小节我们就会分析创建Surface的过程，即我们自己编写程序中的：
sp surfaceControl = client->createSurface(String8("resize"),
下面是其详细的调用过程，从做下角A2处开始看起： 
根据前面的分析，我们先做一些总结：
APP：
1.client = new SurfaceComposerClient()，实例化对象中存在mClient，其为BpSurfaceComposerClient（代理）类型，
指向SurfaceFlinger中派生于BnSurfaceComposerClient的new client
2.调用client->createSurface最终导致mClient中的函数被调用，进而导致BnSurfaceComposerClient的相关函数被调用。
其为那些函数，后续分析代码中为大家讲解。
下面是一个图： 
看起来比较杂乱无章，不过没关系，后续会慢慢的进行讲解，就不会觉得杂乱了。
首先我们打开SurfaceComposerClient.cpp文件，根据我们编写程序中的：
sp surfaceControl = client->createSurface(String8("resize"),
在文件中查找createSurface：
status_t err = mClient->createSurface(name, w, h, format, flags,&handle, &gbp);
其通过binder远程调用，将会导致SurfaceFlinger中与之对应的client中的createSurface被调用。那么会产生什么结果呢？：对于APP的每一个Surface创建一个Layer，Layer中包含了生产者，消费者。其中生产者，消费者指向同一个BufferQueueCore。BufferQueueCore中存在ButterSlot[64]数组。
前面提到，测试程序中：
/*获得SurfaceComposerClient服务*/
sp client = new SurfaceComposerClient();
/*创建Surface*/
sp surfaceControl = client->createSurface(String8("resize"),
进入SurfaceComposerClient.cpp文件，搜索createSurface：
status_t err = mClient->createSurface(name, w, h, format, flags,&handle, &gbp);
这里的mClient是一个BpSurfaceComposerClient代理类，他是在ISurfaceComposerClient.cpp中被实现，进入该文件，其中肯定存在
class BpSurfaceComposerClient : public BpInterface
virtual status_t createSurface(const String8& name, uint32_t width,uint32_t height, PixelFormat format, uint32_t flags,sp* handle,sp* gbp) {
/*构造数据*/
Parcel data, reply;
/*通过binder发送数据，其中第一个参数为CREATE_SURFACE*/
remote()->transact(CREATE_SURFACE, data, &reply);
现在我们分析的是代理端，那么服务那一边肯定会根据这些数据以及CREATE_SURFACE（code值），决定调用相关的函数。现在我们看看服务端，即nactive。进入Client.cpp查看,其中肯定存在createSurface
我们可以在Client.cpp中找到createSurface，即应用程序调用createSurface导致Client类中的createSurface被调用：
status_t Client::createSurface(const String8& name,uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, sp* handle,sp* gbp)
/*创建一个MessageBase msg */
sp msg = newMessageCreateLayer(mFlinger.get(),name, this, w, h, format, flags, handle, gbp);
/*提交msg*/
mFlinger->postMessageSync(msg);
postMessageSync实际上会导致
virtual bool handler() {
result = flinger->createLayer(name, client, w, h, format, flags,
handle, gbp);
return true;
}
被调用，其中flinger就是SurfaceFlinger，我们进入SurfaceFlinger.cpp，查找createLayer：
status_t SurfaceFlinger::createLayer(
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceNormal:
result = createNormalLayer(client,name, w, h, flags,format,handle, gbp, &layer);
*outLayer = new Layer(this, client, name, w, h, flags);
break;
前面提到过，对于APP打开的的每一个Surface都会创建一个Layer，并且Layer中包括了生产者和消费者以及BufferQueueCore，那么在这个场景中，生产者是谁？当然是我们应用程序，所以再应用程序，还存在一个代理类，其指向SurfaceFlinger真正的生产者对象。当然这是我们的猜测，下面我们分析创建Layer的过程。
*outLayer = new Layer(this, client, name, w, h, flags);
void Layer::onFirstRef() {
// Creates a custom BufferQueue for SurfaceFlingerConsumer to use，在其中还会创建producer，consumer
BufferQueue::createBufferQueue(&producer, &consumer);
.
/*创建BufferQueueCore*/
sp core(new BufferQueueCore(allocator));
/*后续深入分析，其是作用是分配内存*/
mAllocator = composer->createGraphicBufferAlloc();
/*创建producer*/
sp producer(new BufferQueueProducer(core));
/*创建consumer*/
sp consumer(new BufferQueueConsumer(core));
/*其实是对producer的封装*/
mProducer = new MonitoredProducer(producer, mFlinger);
/*其实是对consumer的封装*/
mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName,this);
大致的流程如上，我们在BufferQueueCore.cpp中可以找到BufferQueueCore的成员:
BufferQueueDefs::SlotsType mSlots;
其为一个数组，在BufferQueueProducer.cpp中可以找到mCore(core)以mSlots(core->mSlots),及，mCore(core)他指向之前通过：
sp core(new BufferQueueCore(allocator));
创建的core，这里的mSlots(core->mSlots)为一个引用，指向core->mSlots。
我们再进入BufferQueueConsumer.cpp文件，其也存在：
mCore(core),
mSlots(core->mSlots),
他们的指向与BufferQueueProducer.cpp中的相同。
通过createBufferQueue执行之后，有了最初的producer与consumer，后面通过MonitoredProducer与SurfaceFlingerConsumer函数对其进行加工封装。先来看看MonitoredProducer函数。
mProducer = new MonitoredProducer(producer, mFlinger);
/*指向前面的producer*/
mProducer(producer),
再来查看SurfaceFlingerConsumer
mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer,mTextureName,this);
SurfaceFlingerConsumer(const sp& consumer,
uint32_t tex, const Layer* layer)
: GLConsumer(consumer, tex, GLConsumer::TEXTURE_EXTERNAL, false, false),
mTransformToDisplayInverse(false), mSurfaceDamage(),
mPrevReleaseFence(Fence::NO_FENCE), mLayer(lay
可以看到起会调用父类的GLConsumer函数，继续调用更高的父类ConsumerBase(bq, isControlledByApp),的构造函数：
ConsumerBase::ConsumerBase(const sp& bufferQueue, bool controlledByApp) :
mAbandoned(false),
mConsumer(bufferQueue) {
可以知道其中存在mConsumer，其也指向之前分析的mConsumer，即真正的消费者。
以上分析都是对远程调用的分析，那么他怎么返回结果给我们应用程序？进入我们自己编写的应用程序：
sp surfaceControl = client->createSurface(String8("resize"),
其会调用SurfaceComposerClient.cpp的createSurface：
sp SurfaceComposerClient::createSurface(
/*创建一个代理类。BpGraphicBufferProducer*/
sp gbp;
status_t err = mClient->createSurface(name, w, h, format, flags,&handle, &gbp);
sur = new SurfaceControl(this, handle, gbp);
return sur;
这样就返回了，其中mClient->createSurface最终会调用到ISurfaceComposerClient.cpp中：
class BpSurfaceComposerClient : public BpInterface
remote()->transact(DESTROY_SURFACE, data, &reply);
/*远程调用之后的结果保存到gbp */
*gbp = interface_cast(reply.readStrongBinder());
interface_cast通过binder从reply读取数据，其属于代理边，那么是谁写入数据呢？
其是在BnSurfaceFlingerClient中设置gbp的返回值。
前面提到，远程调用会导致ISurfaceComposerClient.cpp中的onTransact被调用：
status_t BnSurfaceComposerClient::onTransact(
case CREATE_SURFACE: {
status_t result = createSurface(name, width, height, format,createFlags, &handle, &gbp);
/*往Binder中写入数据*/
reply->writeStrongBinder(handle);
reply->writeStrongBinder(IInterface::asBinder(gbp));
下面我们要确定gbp是什么，其为之前的mProducer :
mProducer = new MonitoredProducer(producer, mFlinger);
asBinder(gbp)是一个BufferQueueProduce对象，当调用asBinder会导致MonitoredProducer.cpp中的MonitoredProducer::onAsBinder()被调用。
应用程序：
/*获得SurfaceComposerClient服务*/
sp client = new SurfaceComposerClient();
/*创建Surface*/
sp surfaceControl = client->createSurface(String8("resize"),
我们回到SurfaceComposerClient…cpp中的：
sp SurfaceComposerClient::createSurface(
/*创建一个代理类。BpGraphicBufferProducer*/
sp gbp;
status_t err = mClient->createSurface(name, w, h, format, flags,&handle, &gbp);
sur = new SurfaceControl(this, handle, gbp);
return sur;
其通过远程调用，获得了一个生产者gbp，使用gbp创建出一个SurfaceControl然后返回。
下面是一个总结的框图： 
在应用层程序这边：如果使用SurfaceFlinger服务，SurfaceFlinger中就会有一个与之对应的client，当APP创建一个Surface的到一个SurfaceCotrl，SurfaceFlinger就会存在一个Layer与之对应。
SurfaceCotrl中有一个生产者gbp，其指向Layer中的mproducer（MonitoredProducer类型）中的mproducer，即mproducer中还存在一个成员mproducer（BufferQueueBroducer类型）
mproducer与gbp都遵循同一个接口IGraphicBufferProducer.IGraphicBufferProducer在本地（SurfaceFlinger）边派生出BnGraphicBufferProducer，在由BnGraphicBufferProducer派生出BufferQueueProducer。在应用程序派生出BpGraphicBufferProducer.
回到应用程序：
// create a client to surfaceflinger
/*获得SurfaceComposerClient服务*/
sp client = new SurfaceComposerClient();
/*创建Surface*/
sp surfaceControl = client->createSurface(String8("resize"),
160, 240, PIXEL_FORMAT_RGB_565, 0);
sp surface = surfaceControl->getSurface();
得到surfaceControl之后，使用surfaceControl->getSurface()，就能获得一个surface ，
sp SurfaceControl::getSurface() const
mSurfaceData = new Surface(mGraphicBufferProducer, false);
在SurfaceControl的构造函数中：
SurfaceControl::SurfaceControl(
const sp& client,
const sp& handle,
const sp& gbp)
: mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)
gbp会被当做参数，传递给mGraphicBufferProducer，通过mSurfaceData = new Surface(mGraphicBufferProducer, false);获得的Surface是我们后面的核心，其中存在一个生产者。下小节，我们将分析该生产者。
