07.显示系统:第004课_SurfaceFlinger内部机制:第003节_APP申请创建Surface的过程

时间  2021-01-12

在之前的课时中，编写了SurfaceTest.cpp测试程序，该课时我们通过这个简单的程序去了解SurfaceFlinger内部机制内部机制。我们再来回顾一下SurfaceTest的步骤，主要如下图所示：
在这里插入图片描述
在上小节中，讲解了应用程序创建SurfaceFlinger客户端(client)，即获得服务，创建一个client的过程，我们来回顾一下。
1.获得SurfaceFlinger服务
2.调用服务的createConnection函数建立一个连接，即应用程序与SurfaceFlinger的联系
3.SurfaceFlinger中会创建一个client对象，在APP应用程序边，会获得一个代理类的对象，后续可以使用这个代理类创建surface。

该小节我们就会分析创建Surface的过程，即我们自己编写程序中的：

sp<SurfaceControl> 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> 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<SurfaceComposerClient> client = new SurfaceComposerClient();
    
	/*创建Surface*/
    sp<SurfaceControl> 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<ISurfaceComposerClient>
    virtual status_t createSurface(const String8& name, uint32_t width,uint32_t height, PixelFormat format, uint32_t flags,sp<IBinder>* handle,sp<IGraphicBufferProducer>* 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<IBinder>* handle,sp<IGraphicBufferProducer>* gbp)
	/*创建一个MessageBase msg */
	sp<MessageBase> 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<BufferQueueCore> core(new BufferQueueCore(allocator));
 	    	 	 /*后续深入分析，其是作用是分配内存*/
 	    		 mAllocator = composer->createGraphicBufferAlloc();
 	    	/*创建producer*/
 	    	sp<IGraphicBufferProducer> producer(new BufferQueueProducer(core));
				
 	    	/*创建consumer*/
 	    	sp<IGraphicBufferConsumer> 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<BufferQueueCore> 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<IGraphicBufferConsumer>& 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<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
        mAbandoned(false),
        mConsumer(bufferQueue) {

可以知道其中存在mConsumer，其也指向之前分析的mConsumer，即真正的消费者。

以上分析都是对远程调用的分析，那么他怎么返回结果给我们应用程序？进入我们自己编写的应用程序：

sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"),

其会调用SurfaceComposerClient.cpp的createSurface：

sp<SurfaceControl> SurfaceComposerClient::createSurface(
	/*创建一个代理类。BpGraphicBufferProducer*/
	sp<IGraphicBufferProducer> 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<ISurfaceComposerClient>
	remote()->transact(DESTROY_SURFACE, data, &reply);
	/*远程调用之后的结果保存到gbp */
	*gbp = interface_cast<IGraphicBufferProducer>(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<SurfaceComposerClient> client = new SurfaceComposerClient();
    
	/*创建Surface*/
    sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"),

我们回到SurfaceComposerClient…cpp中的：

sp<SurfaceControl> SurfaceComposerClient::createSurface(
	/*创建一个代理类。BpGraphicBufferProducer*/
	sp<IGraphicBufferProducer> 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<SurfaceComposerClient> client = new SurfaceComposerClient();
    
	/*创建Surface*/
    sp<SurfaceControl> surfaceControl = client->createSurface(String8("resize"),
            160, 240, PIXEL_FORMAT_RGB_565, 0);

    sp<Surface> surface = surfaceControl->getSurface();

得到surfaceControl之后，使用surfaceControl->getSurface()，就能获得一个surface ，

sp<Surface> SurfaceControl::getSurface() const
	mSurfaceData = new Surface(mGraphicBufferProducer, false);

在SurfaceControl的构造函数中：

SurfaceControl::SurfaceControl(
        const sp<SurfaceComposerClient>& client,
        const sp<IBinder>& handle,
        const sp<IGraphicBufferProducer>& gbp)
    : mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)

gbp会被当做参数，传递给mGraphicBufferProducer，通过mSurfaceData = new Surface(mGraphicBufferProducer, false);获得的Surface是我们后面的核心，其中存在一个生产者。下小节，我们将分析该生产者。

联系我们 沪ICP备2021010478号-7