07.显示系统:第004课_SurfaceFlinger内部机制:第002节_APP创建SurfaceFlinger客户端(client)的过程

江南才尽，年少无知！

已于 2022-07-18 14:41:49 修改

阅读量544

点赞数 7

CC 4.0 BY-SA版权

分类专栏： RK3399移植文章标签：服务器 java 运维

于 2019-03-27 10:34:43 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43013761/article/details/88838430

RK3399移植专栏收录该内容

119 篇文章

订阅专栏

本文详细解析了在Android系统中创建SurfaceFlinger客户端的过程。主要包括客户端构造函数的执行流程、跨进程调用机制以及SurfaceFlinger服务端如何响应客户端请求并创建对应的连接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

该小节我们讲解创建SurfaceFlinger客服端(client)的过程，之前我们的测试程序中，其前面就执行了如下代码：

sp<SurfaceComposerClient> client = new SurfaceComposerClient();

下图是上述代码内部的调用关系：
在这里插入图片描述
如果想详细的分析其内部实现，可以参考该图，分析源代码。

我们先在源码中看看其内部执行过程。

源码分析

通过前面小节的讲解，我们知道每一个使用SurfaceFlinger的应用程序，在SurfaceFlinger之中，都存在一个与其对应的client，这个client的创建，是由应用程序引起的，只要执行了：

sp<SurfaceComposerClient> client = new SurfaceComposerClient();

在SurfaceFlinger中就会创建对应的client，其sp代表该是一个智能指针，在创建client时，首先会执行器构造函数，并且在第一次引用时，还会执行SurfaceComposerClient.cpp中的onFirstRef函数，：

/*构造函数*/
SurfaceComposerClient::SurfaceComposerClient()
    : mStatus(NO_INIT), mComposer(Composer::getInstance())
{
}
/*第一次被引用时执行*/
void SurfaceComposerClient::onFirstRef() {
    sp<ISurfaceComposer> sm(ComposerService::getComposerService());
    if (sm != 0) {
        sp<ISurfaceComposerClient> conn = sm->createConnection();
        if (conn != 0) {
            mClient = conn;
            mStatus = NO_ERROR;
        }
    }
}

我们先来想象一下怎么去创建这个client：
1.获得服务
2.使用它的函数（通过远程调用）创建client

根据上面两点，可以知道，至少涉及两个程序，即应用程序与SurfaceFlinger服务，他们之间是通过binder进行通信的。SurfaceFlinger服务对应的进程是Main_surfaceflinger.cpp，其代码比较简洁，其中存在语句：

sp<SurfaceFlinger> flinger = new SurfaceFlinger();
sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);

我们来看看其中的SurfaceFlinger，在SurfaceFlinger.h文件中：

class SurfaceFlinger : public BnSurfaceComposer,
                       private IBinder::DeathRecipient,
                       private HWComposer::EventHandler
{

其中BnSurfaceComposer：

class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {

其是遵循接口ISurfaceComposer，下面是一个类图：
在这里插入图片描述
ISurfaceComposer为一个虚拟接口，在图的右边我们可以看到，其肯定有一个本地的BnSurfaceComposer对其进行实现，然后由他派生了SurfaceFlinger。在图的左边，在get-SurfaceComposer时，会有一个代理类BpSurfaceComposer，这些都是我们前面学习binder驱动了解到的知识。即：一个接口，一个本地实现，还有一个代理类。

下面我们来看看SurfaceComposerClient.cpp中的onFirstRef函数：

onFirstRef()
	/*其就是BpSurfaceComposer的实例化对象*/
	sp<ISurfaceComposer> sm(ComposerService::getComposerService());
		/*getComposerService函数中，获得其实例化*/
		ComposerService& instance = ComposerService::getInstance();
		/*进行连接上锁绑定*/
		ComposerService::getInstance().connectLocked();
			const String16 name("SurfaceFlinger");
			/*最终在connectLocked函数中，我们知道了其如何获取服务
			其服务保存在变量mComposerService之中，然后返回*/
			getService(name, &mComposerService)
	/*调用ComposerService实例化对象的createConnection方法，其是一个跨进程的调用函数*/
	sp<ISurfaceComposerClient> conn = sm->createConnection();

为了好的分析createConnection函数，我们进入ISurfaceComposer.cpp文件，其中肯定存在一个代理类BpSurfaceComposer:

class BpSurfaceComposer : public BpInterface<ISurfaceComposer>{
	virtual sp<ISurfaceComposerClient> createConnection(){
        Parcel data, reply;     
        /*构造reply数据*/  
        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
        /*发起远程调用，会导致SurfaceFlinger进程中的onTransact被调用*/
        remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
        return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
    }
}

从上面我们可以知道，会发起一个远程调用，调用SurfaceFlinger进程中的onTransact，我们进入SurfaceFlinger.cpp查看：

status_t SurfaceFlinger::onTransact(
	/*根据code做不同的处理*/
	switch (code) {
	    ......
        case CREATE_CONNECTION:
        ......
    /*调用其父类的onTransact，位于ISurfaceComposer.cpp*/
    BnSurfaceComposer::onTransact(code, data, reply, flags);
    	case CREATE_CONNECTION: {
    		sp<IBinder> b = IInterface::asBinder(createConnection());
    		reply->writeStrongBinder(b);

因为在SurfaceFlinger中实现了createConnection，所以会调用SurfaceFlinger.cpp中的createConnection。

sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
	/*创建一个client对象，然后返回*/
	sp<Client> client(new Client(this));

创建client之后，回到前面的：

sp<IBinder> b = IInterface::asBinder(createConnection());

可以看到返回给了sp b ，然后在此通过binder进行远程调用，在ISurfaceComposer.cpp文件：

class BpSurfaceComposer : public BpInterface<ISurfaceComposer>{
	/*远程调用*/
	remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
	/*返回给我们应用程序*/
	return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());

传递给我们应用程序SurfaceTest.cpp：

sp<SurfaceComposerClient> client = new SurfaceComposerClient();

小节总结

为了形象的了解到其中的过程，下面是一个大概的图示：
在这里插入图片描述
首先APP中存在一个代理
1.BpSurfaceComposer：构造数据，通过binder进行remote()->transact远程调用，导致SurfaceFlinger进程中的onTransact被调用。
2.SurfaceFlinger进程中的onTransact会调用其父类BpSurfaceComposer (ISurfaceComposer)的onTransact函数.
3.父类的onTransact会调用：sp b = IInterface::asBinder(createConnection())；与reply->writeStrongBinder(b);其中createConnection在派生类SurfaceFlinger中有实现。writeStrongBinder通过binder返回给BpSurfaceComposer。
5.BpSurfaceComposer中再调用return interface_cast(reply.readStrongBinder());，返回给我们编写的SurfaceTest.cpp程序
6.在createConnection中创建了一个client对象，其中

class Client : public BnSurfaceComposerClient

class BnSurfaceComposerClient: public BnInterface<ISurfaceComposerClient> {

可以看出ISurfaceComposerClient为一个接口，需要本地实现。并且派生出了一个client类。ISurfaceComposerClient肯定存在其一个代理类，BpSurfaceComposerClient。