zoukankan      html  css  js  c++  java

  • Android应用程序请求SurfaceFlinger服务创建Surface的过程分析

    文章转载至CSDN社区罗升阳的安卓之旅，原文地址：http://blog.csdn.net/luoshengyang/article/details/7884628

    前面我们已经学习过Android应用程序与SurfaceFlinger服务的连接过程了。连接上SurfaceFlinger服务之后，Android应用程序就可以请求SurfaceFlinger服务创建Surface。而当有了Surface后，Android应用程序就可以用来渲染自己的UI了。在本文中，我们将详细分析Android应用程序请求SurfaceFlinger服务创建Surface的过程。

            在讲述Android应用程序请求SurfaceFlinger服务创建Surface之前，我们首先了解一个Surface是由什么组成的。我们可以将Surface理解为一个绘图表面，Android应用程序负责往这个绘图表面填内容，而SurfaceFlinger服务负责将这个绘图表面的内容取出来，并且渲染在显示屏上。

            在SurfaceFlinger服务这一侧，绘图表面使用Layer类来描述，Layer类的实现如图1所示。


    图1 Layer类的实现

           Layer类继承了LayerBaseClient类；LayerBaseClient类继承了LayerBase类；LayerBase类继续了RefBase类。从这些继承关系就可以看出，我们可以通过Android系统的智能指针来引用Layer对象，从而可以自动地维护它们的生命周期。

           Layer类内部的成员变量mUserClientRef指向了一个ClientRef对象，这个ClientRef对象内部有一个成员变量mControlBlock，它指向了一个SharedBufferServer对象。从前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文可以知道，SharedBufferServer类是用来在SurfaceFlinger服务这一侧描述一个UI元数据缓冲区堆栈的，即在SurfaceFlinger服务中，每一个绘图表面，即一个Layer对象，都关联有一个UI元数据缓冲区堆栈。

           LayerBaseClient类内部有一个类型为LayerBaseClient::Surface的弱指针，它引用了一个 Layer::SurfaceLayer对象。这个Layer::SurfaceLayer对象是一个Binder本地对象，它是 SurfaceFlinger服务用来与Android应用程序建立通信的，以便可以共同维护一个绘图表面。

           Layer::SurfaceLayer类继承了LayerBaseClient::Surface类，它的实现如图2所示。


    图2 SurfaceLayer类的实现

           理解这个图需要了解Android系统的Binder进程间通信机制，具体可以参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。从这里就可以看出，Layer::SurfaceLayer类实现了ISurface接口，而Android应用程序就是通过这个接口来和SurfaceFlinger服务共同维护一个绘图表面的。

           Layer::SurfaceLayer类内部有两个成员变量mFlinger和mOwner，前者指向了SurfaceFlinger服务，而后者指向了其宿主Layer对象。

           ISurface接口定义在文件frameworks/base/include/surfaceflinger/ISurface.h中，它有一个重要的成员函数requestBuffer，如下所示：

     

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. class ISurface : public IInterface  
    2. {  
    3.     ......  
    4.   
    5. public:  
    6.     DECLARE_META_INTERFACE(Surface);  
    7.   
    8.     /* 
    9.      * requests a new buffer for the given index. If w, h, or format are 
    10.      * null the buffer is created with the parameters assigned to the 
    11.      * surface it is bound to. Otherwise the buffer's parameters are 
    12.      * set to those specified. 
    13.      */  
    14.     virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,  
    15.             uint32_t w, uint32_t h, uint32_t format, uint32_t usage) = 0;  
    16.   
    17.     ......  
    18.   
    19. };  


            Android应用程序就是通过ISurface接口的成员函数requestBuffer来请求SurfaceFlinger服务为它的一个绘图表面分配一个图形缓冲区的，这个图形缓冲区使用一个GraphicBuffer对象来描述。

            由于Layer::SurfaceLayer是一个Binder本地对象类，因此，就相应地有一个Binder代理对象类，它的名称为BpSurface，它的实现如图3所示。


    图3 BpSurface类的实现

           理解这个图同样需要了解Android系统的Binder进程间通信机制，具体可以参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。

           以上都是从SurfaceFlinger服务这一侧来理解一个Surface，下面我们再从Android应用程序这一侧来理解一个Surface。

           在Android应用程序这一侧，每一个绘图表面都使用一个Surface对象来描述，每一个Surface对象都是由一个SurfaceControl对象来创建的。Surface类和SurfaceControl类的关系以及实现如图4所示。


    图4 Surface类和SurfaceControl类的关系以及实现

           SurfaceControl类的成员变量mClient是一个类型为SurfaceComposerClient的强指针，它指向了Android应用程序进程中的一个SurfaceComposerClient单例对象。在前面Android应用程序与SurfaceFlinger服务的连接过程分析一 文中，我们已经看到过SurfaceComposerClient类的作用了，Android应用程序主要就是通过它来和SurfaceFlinger服 务建立连接的，连接的结果就是得到一个类型为Client的Binder代理对象，保存它的成员变量mClient中。

          SurfaceControl类的成员变量mSurface是一个类型为ISurface的强指针，它指向了一个类型为BpSurface的 Binder代理对象，而这个Binder代理对象引用的是一个Layer::SurfaceLayer对象。当Android应用程序请求 SurfaceFlinger服务创建一个绘图表面的时候，SurfaceFlinger服务就会在内部创建一个Layer::SurfaceLayer 对象，并且将这个Layer::SurfaceLayer对象的一个Binder代理对象返回来给Android应用程序，然后Android应用程序再 将这个Binder代理对象保存在一个SurfaceControl对象的成员变量mSurface中。

          SurfaceControl类的成员变量mSurfaceData是一个类型为Surface的强指针，它指向了一个Surface对象。

          Surface类就是用来在Android应用程序这一侧描述绘图表面的，它的成员变量mSurface与它的宿主类SurfaceControl的成 员变量mSurface指向的是同一个Binder代理对象，即它们都引用了在SurfaceFlinger服务内部所创建的一个类型为 Layer::SurfaceLayer的Binder本地对象。

          Surface类的成员变量mClient指向了Android应用程序进程中的一个SurfaceClient单例对象。在前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文中，我们已经介绍过SurfaceClient类的实现了，Android应用程序就是通过它来请求SurfaceFlinger服务创建共享UI元数据的，并且可以通过它来请求SurfaceFlinger服务渲染一个绘图表面。

          Surface类的成员变量mSharedBufferClient指向了一个SharedBufferClient对象。从前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文可以知道，SharedBufferClient类是用来在Android应用程序这一侧描述一个UI元数据缓冲区堆栈的，即在Android应用程序中，每一个绘图表面，即一个Surface对象，都关联有一个UI元数据缓冲区堆栈。

          Surface类继承了EGLNativeBase类，而EGLNativeBase类又继承了ANativeWindow类。我们知 道，Android系统是通过OpenGL库来绘制UI的。OpenGL库在绘制UI的时候，需要底层的系统提供一个本地窗口给它，以便它可以将UI绘制 在这个本地窗口上。Android系统为OpenGL库定提供的本地窗口使用ANativeWindow类来描述，Surface类通过 EGLNativeBase类间接地继承了ANativeWindow类，因此，Surface类也是用来描述OpenGL绘图所需要的一个本地窗口的。 从这个角度出发，我们可以将Surface类看作OpenGL库与Android的UI系统之间的一个桥梁。

          讨论到这里，我们就可以知道，一个绘图表面，在SurfaceFlinger服务和Android应用程序中分别对应有一个Layer对象和一个 Surface对象，这两个对象在内部分别使用一个SharedBufferServer对象和一个SharedBufferClient对象来描述这个 绘图表面的UI元数据缓冲堆栈。在前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文中，我们已经分析过这个UI元数据的创建过程了，接下来，我们再简要看一下SharedBufferServer类和SharedBufferClient类的定义。

          SharedBufferServer类和SharedBufferClient类均是从SharedBufferBase类继承下来的，如图5所示。


    图5 SharedBufferBase、SharedBufferServer和SharedBufferClient的关系

          在基类SharedBufferBase中，有三个成员变量mSharedClient、mSharedStack和mIdentity。成员变量 mSharedClient指向一块UI元数据缓冲区，即一个SharedClient对象；成员变量mSharedStack指向一个UI元数据堆栈， 即一个SharedBufferStack对象；成员变量mIdentity用来描述一个绘图表面的ID。

          在前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一 文提到，每一个与UI相关的Android应用程序内部都有一个唯一的SharedClient对象，这个SharedClient对象内部有一个 SharedBufferStack数组surfaces，SharedBufferServer类的成员变量mSharedStack所指向的 SharedBufferStack对象，正是成员变量mSharedClient所指向的一个SharedClient对象内部的一个 SharedBufferStack数组的一个元素，这一点可以从SharedBufferServer类的构造函数实现来看出。

          SharedBufferServer类的构造函数frameworks/base/libs/surfaceflinger_client/SharedBufferStack.cpp文件中，如下所示：

     

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. SharedBufferBase::SharedBufferBase(SharedClient* sharedClient,  
    2.         int surface, int32_t identity)  
    3.     : mSharedClient(sharedClient),  
    4.       mSharedStack(sharedClient->surfaces + surface),  
    5.       mIdentity(identity)  
    6. {  
    7. }  

           其中，参数surface表示mSharedStack指向的是mSharedClient中的SharedBufferStack数组surfaces的第几个元素。

           在SharedBufferClient类中，有三个成员变量mNumBuffers、tail和queue_head，它们的含义可以参考前面Android应用程序与SurfaceFlinger服务的关系概述和学习计划一文中的图6，如下所示。

    图6 SharedBufferClient眼中的SharedBufferStack 

           在Android应用程序这一侧，当它需要渲染一个Surface时，它就会首先找到对应的SharedBufferClient对象，然后再调用它的成 员函数dequeue来请求分配一个UI元数据缓冲区。有了这个UI元数据缓冲区之后，Android应用程序再调用这个 SharedBufferClient对象的成员函数setDirtyRegion、setCrop和setTransform来设置对应的 Surface的裁剪区域、纹理坐标以及旋转方向。此外，Android应用程序还会请求SurfaceFlinger服务为这个Surface分配一个 图形缓冲区，以便可以往这个图形缓冲区写入实际的UI数据。最后，Android应用程序就可以调用这个SharedBufferClient对象的成员 函数queue把前面已经准备好了的UI元数据缓冲区加入到它所描述的一个UI元数据缓冲区堆栈的待渲染队列中，以便SurfaceFlinger服务可 以在合适的时候对它进行渲染。这个过程我们在下一篇文章中再详细分析。

           SharedBufferServer类的成员变量mNumBuffers的含义可以参考前面Android应用程序与SurfaceFlinger服务的关系概述和学习计划一文中的图7，如下所示。

    图7 SharedBufferServer眼中的SharedBufferStack

            当SurfaceFlinger服务需要渲染一个Surface的时候，它就会找到对应的一个SharedBufferServer对象，然后调用它的 成员函数getQueueCount来检查它所描述的一个UI元数据缓冲区堆栈的待渲染队列的大小。如果这个大小大于0，那么 SurfaceFlinger服务就会继续调用它的成员函数retireAndLock来取出队列中的第一个UI元数据缓冲区，以及调用它的成员函数 getDirtyRegion、getCrop和getTransform来获得要渲染的Surface的裁剪区域、纹理坐标和旋转方向。最 后，SurfaceFlinger服务就可以结合这些信息来将保存这个Surface的图形缓冲区中的UI数据渲染在显示屏中。这个过程我们同样在下一篇 文章中再详细分析。

           SharedBufferServer类的另外一个成员变量mBufferList指向了一个BufferList对象，这个BufferList对 象是用来管理SharedBufferServer类所描述的一个UI元数据缓冲区堆栈的，接下来我们就简要分析它的定义。

           BufferList类定义在frameworks/base/include/private/surfaceflinger/SharedBufferStack.h文件中，如下所示：

     

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. class SharedBufferServer  
    2.     : public SharedBufferBase,  
    3.       public LightRefBase<SharedBufferServer>  
    4. {  
    5.     ......  
    6.   
    7. private:  
    8.     ......  
    9.   
    10.     /* 
    11.      * BufferList is basically a fixed-capacity sorted-vector of 
    12.      * unsigned 5-bits ints using a 32-bits int as storage. 
    13.      * it has efficient iterators to find items in the list and not in the list. 
    14.      */  
    15.     class BufferList {  
    16.         size_t mCapacity;  
    17.         uint32_t mList;  
    18.     public:  
    19.         BufferList(size_t c = SharedBufferStack::NUM_BUFFER_MAX)  
    20.             : mCapacity(c), mList(0) { }  
    21.         status_t add(int value);  
    22.         status_t remove(int value);  
    23.         uint32_t getMask() const { return mList; }  
    24.   
    25.         class const_iterator {  
    26.             friend class BufferList;  
    27.             uint32_t mask, curr;  
    28.             const_iterator(uint32_t mask) :  
    29.                 mask(mask), curr(__builtin_clz(mask)) {  
    30.             }  
    31.         public:  
    32.             inline bool operator == (const const_iterator& rhs) const {  
    33.                 return mask == rhs.mask;  
    34.             }  
    35.             inline bool operator != (const const_iterator& rhs) const {  
    36.                 return mask != rhs.mask;  
    37.             }  
    38.             inline int operator *() const { return curr; }  
    39.             inline const const_iterator& operator ++() {  
    40.                 mask &= ~(1<<(31-curr));  
    41.                 curr = __builtin_clz(mask);  
    42.                 return *this;  
    43.             }  
    44.         };  
    45.   
    46.         inline const_iterator begin() const {  
    47.             return const_iterator(mList);  
    48.         }  
    49.         inline const_iterator end() const   {  
    50.             return const_iterator(0);  
    51.         }  
    52.         inline const_iterator free_begin() const {  
    53.             uint32_t mask = (1 << (32-mCapacity)) - 1;  
    54.             return const_iterator( ~(mList | mask) );  
    55.         }  
    56.     };  
    57.   
    58.     ......  
    59. };  

           BufferList类的成员变量mCapacity对应于一个UI元数据缓冲区堆栈的容量，即最大缓冲区个数。

           BufferList类的另外一个成员变量变量mList用来描述这个堆栈中的缓冲区哪个是空闲的，哪个是正在使用的。空闲的缓冲区对应的位为0，而正在 使用的缓冲区对应的位为1。举个例子，假如一个UI元数据缓冲区堆栈的大小为5，其中，第1、3、5个数据缓冲区是正在使用的，而第2、4个数据缓冲区是 空闲的，那么对应的mList的值就等于10101000 00000000 00000000 00000000。当我们需要将第2个数据缓冲区设置为正在使用时，那么只要调用成员函数add来将左起第2位设置为1即可，即得到mList的值就等于 11101000 00000000 00000000 00000000，而当我们需要将第1个数据缓冲区设置为空闲时，那么只要调用成员函数remove来将左起第1位设置为0即可，即得到mList的值就 等于00101000 00000000 00000000 00000000。

          在BufferList类内部定义了一个迭代器const_iterator，用来从左到右遍历一个UI元数据缓冲区堆栈中的正在使用或者空闲的缓冲区。仍然以前面的例子为例，当 我们调用BufferList类的成员函数begin时，就可以得到一个const_iterator迭代器，沿着这个迭代器往前走，就可以依次遍历第 1、3、5个正在使用的缓冲区，而当我们调用BufferList类的成员函数free_begin时，就可以得到另外一个const_iterator 迭代器，沿着这个迭代器往前走，就可以依次遍历第2、4个空闲的缓冲区。

          关于Surface的概念我们就分析到这里。从这些分析可以知道，当Android应用程序请求SurfaceFlinger服务创建一个 Surface的时候，需要在SurfaceFlinger服务这一侧创建一个Layer对象、一个Layer::SurfaceLayer对象和一个 SharedBufferServer对象，同时又需要在Android应用程序这一侧创建一个SurfaceControl对象、一个Surface对 象和一个SharedBufferClient对象。

          在进一步分析Android应用程序请求SurfaceFlinger服务创建Surface的过程之前，我们首先看一下Android系统的开机动画 应用程序bootanim是如何请求SurfaceFlinger服务创建一个Surface来显示开机动画的。

          在前面Android系统的开机画面显示过程分析一文中， 我们分析Android系统的开机动画的显示过程，其中，开机动画应用程序bootanim是在BootAnimation类的成员函数readyToRun中请求SurfaceFlinger服务创建一个用来显示开机动画的Surface的，如下所示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. status_t BootAnimation::readyToRun() {    
    2.     ......  
    3.   
    4.     // create the native surface    
    5.     sp<SurfaceControl> control = session()->createSurface(    
    6.             getpid(), 0, dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);    
    7.     ......    
    8.     
    9.     sp<Surface> s = control->getSurface();  
    10.   
    11.     ......  
    12. }    

          BootAnimation类的成员函数session返回的是一个SurfaceComposerClient对象。有了这个 SurfaceComposerClient对象之后，我们就可以调用它的成员函数createSurface来请求请求SurfaceFlinger服 务在内部创建一个Layer::SurfaceLayer对象，并且将这个Layer::SurfaceLayer对象的代理对象返回来给 SurfaceComposerClient类，SurfaceComposerClient类接着就将这个Layer::SurfaceLayer代理 对象封装成一个SurfaceControl对象，并且返回给BootAnimation类，最后BootAnimation类就可以调用这个 SurfaceControl对象的成员函数getSurface来获得一个Surface对象。

          接下来，我们就从SurfaceComposerClient类的成员函数createSurface开始描述Android应用程序请求SurfaceFlinger服务创建Surface的过程，如图8所示。

    图8 Android应用程序请求SurfaceFlinger服务创建Surface的过程 

           这个过程可以划分为20个步骤，接下来我们就详细分析每一个步骤。

           Step 1. SurfaceComposerClient.createSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<SurfaceControl> SurfaceComposerClient::createSurface(  
    2.         int pid,  
    3.         DisplayID display,  
    4.         uint32_t w,  
    5.         uint32_t h,  
    6.         PixelFormat format,  
    7.         uint32_t flags)  
    8. {  
    9.     String8 name;  
    10.     const size_t SIZE = 128;  
    11.     char buffer[SIZE];  
    12.     snprintf(buffer, SIZE, "<pid_%d>", getpid());  
    13.     name.append(buffer);  
    14.   
    15.     return SurfaceComposerClient::createSurface(pid, name, display,  
    16.             w, h, format, flags);  
    17. }  

           这个函数定义在文件frameworks/base/libs/surfaceflinger_client/SurfaceComposerClient.cpp文件中。

           参数pid用来描述当前进程的PID，参数display的值等于0，表示要在第一个显示屏上创建一个Surface，参数w和h表示要创建的 Surface的宽度和高度，它们的值刚好等于第一个显示屏的宽度和高度，参数format的值等于PIXEL_FORMAT_RGB_565，表示要创 建的Surface的像素格式为PIXEL_FORMAT_RGB_565，即每一个点使用2个字节来描述，其中，R、G和B分量分别占5位、6位和5 位，参数flags是一个默认参数，它等于默认值0，表示要创建的Surface的用途。

           这个函数将参数pid格式化成一个字符串之后，再调用SurfaceComposerClient类的另外一个版本的成员函数createSurface来请求SurfaceFlinger服务创建一个Surface，如下所示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<SurfaceControl> SurfaceComposerClient::createSurface(  
    2.         int pid,  
    3.         const String8& name,  
    4.         DisplayID display,  
    5.         uint32_t w,  
    6.         uint32_t h,  
    7.         PixelFormat format,  
    8.         uint32_t flags)  
    9. {  
    10.     sp<SurfaceControl> result;  
    11.     if (mStatus == NO_ERROR) {  
    12.         ISurfaceComposerClient::surface_data_t data;  
    13.         sp<ISurface> surface = mClient->createSurface(&data, pid, name,  
    14.                 display, w, h, format, flags);  
    15.         if (surface != 0) {  
    16.             result = new SurfaceControl(this, surface, data, w, h, format, flags);  
    17.         }  
    18.     }  
    19.     return result;  
    20. }  


           SurfaceComposerClient类的成员变量mClient指向了一个类型为BpSurfaceComposerClient的Binder 代理对象，它引用了一个类型为Client的Binder本地对象。这个类型Client的Binder本地对象是在SurfaceFlinger服务内 部创建的，用来和Android应用程序建立连接。连接的过程可以参考前面Android应用程序与SurfaceFlinger服务的连接过程分析一文。

           SurfaceComposerClient类的成员函数createSurface调用成员变量mClient的成员函数 createSurface请求SurfaceFlinger服务创建一个Surface之后，就得到了一个类型为BpSurface的Binder代理 对象surface。从前面的描述可以知道，Binder代理对象surface引用了在SurfaceFlinger服务这一侧的一个 Layer::SurfaceLayer对象。此外，SurfaceComposerClient类的成员函数createSurface还得到了一个 surface_data_t对象data，它里面包含了刚才所创建的一个Surface的信息，例如，宽度、高度、像素格式和ID值等。

          最后，SurfaceComposerClient类的成员函数createSurface就将SurfaceFlinger服务返回来的Binder 代理对象surface和surface_data_t对象data封装成一个SurfaceControl对象result，并且返回给调用者。接下 来，我们首先分析SurfaceFlinger服务创建Surface的过程，接着再分析SurfaceControl对象result的封装过程。

          Step 2. Client.createSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<ISurface> Client::createSurface(  
    2.         ISurfaceComposerClient::surface_data_t* params, int pid,  
    3.         const String8& name,  
    4.         DisplayID display, uint32_t w, uint32_t h, PixelFormat format,  
    5.         uint32_t flags)  
    6. {  
    7.     return mFlinger->createSurface(this, pid, name, params,  
    8.             display, w, h, format, flags);  
    9. }  

          这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

          Client类的成员变量mFlinger指向了SurfaceFlinger服务，因此，接下来就会调用SurfaceFlinger类的成员函数createSurface来创建一个Surface。

          Step 3. SurfaceFlinger.createSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<ISurface> SurfaceFlinger::createSurface(const sp<Client>& client, int pid,  
    2.         const String8& name, ISurfaceComposerClient::surface_data_t* params,  
    3.         DisplayID d, uint32_t w, uint32_t h, PixelFormat format,  
    4.         uint32_t flags)  
    5. {  
    6.     sp<LayerBaseClient> layer;  
    7.     sp<LayerBaseClient::Surface> surfaceHandle;  
    8.   
    9.     if (int32_t(w|h) < 0) {  
    10.         LOGE("createSurface() failed, w or h is negative (w=%d, h=%d)",  
    11.                 int(w), int(h));  
    12.         return surfaceHandle;  
    13.     }  
    14.   
    15.     //LOGD("createSurface for pid %d (%d x %d)", pid, w, h);  
    16.     sp<Layer> normalLayer;  
    17.     switch (flags & eFXSurfaceMask) {  
    18.         case eFXSurfaceNormal:  
    19.             if (UNLIKELY(flags & ePushBuffers)) {  
    20.                 layer = createPushBuffersSurface(client, d, w, h, flags);  
    21.             } else {  
    22.                 normalLayer = createNormalSurface(client, d, w, h, flags, format);  
    23.                 layer = normalLayer;  
    24.             }  
    25.             break;  
    26.         case eFXSurfaceBlur:  
    27.             layer = createBlurSurface(client, d, w, h, flags);  
    28.             break;  
    29.         case eFXSurfaceDim:  
    30.             layer = createDimSurface(client, d, w, h, flags);  
    31.             break;  
    32.     }  
    33.   
    34.     if (layer != 0) {  
    35.         layer->initStates(w, h, flags);  
    36.         layer->setName(name);  
    37.         ssize_t token = addClientLayer(client, layer);  
    38.   
    39.         surfaceHandle = layer->getSurface();  
    40.         if (surfaceHandle != 0) {  
    41.             params->token = token;  
    42.             params->identity = surfaceHandle->getIdentity();  
    43.             params->width = w;  
    44.             params->height = h;  
    45.             params->format = format;  
    46.             if (normalLayer != 0) {  
    47.                 Mutex::Autolock _l(mStateLock);  
    48.                 mLayerMap.add(surfaceHandle->asBinder(), normalLayer);  
    49.             }  
    50.         }  
    51.   
    52.         setTransactionFlags(eTransactionNeeded);  
    53.     }  
    54.   
    55.     return surfaceHandle;  
    56. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

           第一个if语句判断参数w和h的值是否为负数，如果是的话，那么就直接出错返回了，因为创建的Surface的宽度和高度值不可能为负数。

           eFXSurfaceNormal、eFXSurfaceBlur、eFXSurfaceDim和eFXSurfaceMask是四个枚举值，它们定 义在文件frameworks/base/include/surfaceflinger/ISurfaceComposer.h中，如下所示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. class ISurfaceComposer : public IInterface  
    2. {  
    3. public:  
    4.     ......  
    5.   
    6.     enum { // (keep in sync with Surface.java)  
    7.         ......  
    8.         ePushBuffers        = 0x00000200,  
    9.   
    10.         eFXSurfaceNormal    = 0x00000000,  
    11.         eFXSurfaceBlur      = 0x00010000,  
    12.         eFXSurfaceDim       = 0x00020000,  
    13.         eFXSurfaceMask      = 0x000F0000,  
    14.     };  
    15.   
    16.     ......  
    17. };  

           回到SurfaceFlinger类的成员函数createSurface中，参数flags的值等于0，因此，在接下来的switch语句中，会调用 SurfaceFlinger类的成员函数createNormalSurface来在显示屏上创建一个Layer。顺便提一句，如果参数flags的值 等于eFXSurfaceBlur或者eFXSurfaceDim，那么就表示要创建的是一个模糊或者渐变的Surface，这两种类型的Surface 是在原有的一个Surface上进行创建的，用来对原来的Surface进行模糊或者渐变处理。

            前面所创建的Layer保存在变量layer中，接下来SurfaceFlinger类的成员函数createNormalSurface会调用来另外 一个成员函数addClientLayer来将它保存在内部的一个列表中，接着再调用前面所创建的Layer的成员函数getSurface来获得一个 Layer::SurfaceLayer对象surfaceHandle。

            在将Layer::SurfaceLayer对象surfaceHandle的一个Binder代理对象返回给Android应用程序之 前，SurfaceFlinger类的成员函数createNormalSurface还会以它的一个IBinder接口为关键字，将前面所创建的 Layer保存在SurfaceFlinger类的成员变量mLayerMap所描述的一个Map中，这样就可以将一个 Layer::SurfaceLayer对象surfaceHandle与它的宿主Layer对象关联起来。

            接下来，我们首先分析SurfaceFlinger类的成员函数createNormalSurface和addClientLayer的实现，接着再分析Layer的成员函数getSurface的实现，以便可以了解一个Surface的创建的过程。

            Step 4. SurfaceFlinger.createNormalSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<Layer> SurfaceFlinger::createNormalSurface(  
    2.         const sp<Client>& client, DisplayID display,  
    3.         uint32_t w, uint32_t h, uint32_t flags,  
    4.         PixelFormat& format)  
    5. {  
    6.     // initialize the surfaces  
    7.     switch (format) { // TODO: take h/w into account  
    8.     case PIXEL_FORMAT_TRANSPARENT:  
    9.     case PIXEL_FORMAT_TRANSLUCENT:  
    10.         format = PIXEL_FORMAT_RGBA_8888;  
    11.         break;  
    12.     case PIXEL_FORMAT_OPAQUE:  
    13. #ifdef NO_RGBX_8888  
    14.         format = PIXEL_FORMAT_RGB_565;  
    15. #else  
    16.         format = PIXEL_FORMAT_RGBX_8888;  
    17. #endif  
    18.         break;  
    19.     }  
    20.   
    21. #ifdef NO_RGBX_8888  
    22.     if (format == PIXEL_FORMAT_RGBX_8888)  
    23.         format = PIXEL_FORMAT_RGBA_8888;  
    24. #endif  
    25.   
    26.     sp<Layer> layer = new Layer(this, display, client);  
    27.     status_t err = layer->setBuffers(w, h, format, flags);  
    28.     if (LIKELY(err != NO_ERROR)) {  
    29.         LOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err));  
    30.         layer.clear();  
    31.     }  
    32.     return layer;  
    33. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

           函数开头的switch语句判断要创建的Surface是否要使用透明色。如果要使用的话，那么就将参数format的值修改为 PIXEL_FORMAT_RGBA_8888。另一方面，如果要创建的Surface不需要使用透明色，那么就将参数format的值修改为 PIXEL_FORMAT_RGB_565或者PIXEL_FORMAT_RGBX_8888，取决于是否定义了宏NO_RGBX_8888。

          函数接下来创建了一个Layer对象，并且调用这个Layer对象的成员函数setBuffers来在内部创建一个Layer::SurfaceLayer对象，最后就将这个Layer对象返回给调用者。

          接下来，我们首先分析Layer对象的创建过程，接着再分析Layer对象的成员函数setBuffers的实现。

          Step 5. new Layer

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. Layer::Layer(SurfaceFlinger* flinger,  
    2.         DisplayID display, const sp<Client>& client)  
    3.     :   LayerBaseClient(flinger, display, client),  
    4.         mGLExtensions(GLExtensions::getInstance()),  
    5.         mNeedsBlending(true),  
    6.         mNeedsDithering(false),  
    7.         mSecure(false),  
    8.         mTextureManager(),  
    9.         mBufferManager(mTextureManager),  
    10.         mWidth(0), mHeight(0), mNeedsScaling(false), mFixedSize(false),  
    11.         mBypassState(false)  
    12. {  
    13. }  

          这个函数定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

          Layer类的构造函数只是执行一些简单的初始化工作，接下来我们再继续分析它的进一步初始化工作，这是通过Layer类的成员函数setBuffers来实现的。

          Step 6. Layer.setBuffers

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. status_t Layer::setBuffers( uint32_t w, uint32_t h,  
    2.                             PixelFormat format, uint32_t flags)  
    3. {  
    4.     // this surfaces pixel format  
    5.     PixelFormatInfo info;  
    6.     status_t err = getPixelFormatInfo(format, &info);  
    7.     if (err) return err;  
    8.   
    9.     // the display's pixel format  
    10.     const DisplayHardware& hw(graphicPlane(0).displayHardware());  
    11.     uint32_t const maxSurfaceDims = min(  
    12.             hw.getMaxTextureSize(), hw.getMaxViewportDims());  
    13.   
    14.     // never allow a surface larger than what our underlying GL implementation  
    15.     // can handle.  
    16.     if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {  
    17.         return BAD_VALUE;  
    18.     }  
    19.   
    20.     PixelFormatInfo displayInfo;  
    21.     getPixelFormatInfo(hw.getFormat(), &displayInfo);  
    22.     const uint32_t hwFlags = hw.getFlags();  
    23.   
    24.     mFormat = format;  
    25.     mWidth  = w;  
    26.     mHeight = h;  
    27.   
    28.     mReqFormat = format;  
    29.     mReqWidth = w;  
    30.     mReqHeight = h;  
    31.   
    32.     mSecure = (flags & ISurfaceComposer::eSecure) ? true : false;  
    33.     mNeedsBlending = (info.h_alpha - info.l_alpha) > 0;  
    34.   
    35.     // we use the red index  
    36.     int displayRedSize = displayInfo.getSize(PixelFormatInfo::INDEX_RED);  
    37.     int layerRedsize = info.getSize(PixelFormatInfo::INDEX_RED);  
    38.     mNeedsDithering = layerRedsize > displayRedSize;  
    39.   
    40.     mSurface = new SurfaceLayer(mFlinger, this);  
    41.     return NO_ERROR;  
    42. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

           参数format是一个整数值，用来描述要创建的Surface的像素格式，函数首先调用另外一个函数getPixelFormatInfo来将它转换为 一个PixelFormatInfo对象info，以便可以获得更多的该种类型的像素格式的信息，例如，一个像素点占多少个字节，每个颜色分量又分别占多 少位等。函数getPixelFormatInfo定义文件frameworks/base/libs/ui/PixelFormat.cpp文件中，有 兴趣的读者可以自己研究一下。

           Layer类的成员函数graphicPlane是从父类LayerBase继承下来，用来获得系统的第N个显示屏，这个成员函数最终又是通过调用SurfaceFlinger类的成员函数graphicPlane来实现的，如下所示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. const GraphicPlane& LayerBase::graphicPlane(int dpy) const  
    2. {  
    3.     return mFlinger->graphicPlane(dpy);  
    4. }  

          SurfaceFlinger类的成员函数graphicPlane的实现如下示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. const GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) const  
    2. {  
    3.     LOGE_IF(uint32_t(dpy) >= DISPLAY_COUNT, "Invalid DisplayID %d", dpy);  
    4.     const GraphicPlane& plane(mGraphicPlanes[dpy]);  
    5.     return plane;  
    6. }  

          SurfaceFlinger类有一个类型为DisplayHardware的数组，它的大小等于4，表示Android系统最多支持4个显示屏，每一 个显示屏都使用一个DisplayHardware对象来描述。实际上，Android系统目前只支持一个显示屏，因此，在调用 SurfaceFlinger类的成员函数graphicPlane的时候，传进来的参数dpy的值都是等于0。

          回到Layer类的成员函数setBuffers中，它接下来获得了用来描述系统第1个显示屏的DisplayHardware对象hw，接着再调用函 数getPixelFormatInfo来获得用来描述该显示屏的像素格式信息的PixelFormatInfo对象displayInfo。

          Layer类的成员函数setBuffers接下来再将要创建的Surface的像素格式以及大小记录下来，即分别将参数format、w和h的值保存 在成员变量mFormat、mWidth、mHeight和mReqFormat、mReqWidth、mReqHeight中。

          Layer类的成员函数setBuffers接下来再检查参数flags的ISurfaceComposer::eSecure位是否等于1。如果等于 1的话，就将成员变量mSecure的值设置为true，否则就设置为false。当参数flags的 ISurfaceComposer::eSecure位等于1的时候，就表示正在创建的Surface的UI数据是可以安全地从一个进程拷贝到另外一个进 程的。有些Surface的UI数据是不可以随便拷贝的，因为这涉及到安全问题，例如，用来创建屏幕截图的Surface的UI数据就是不可以随便从一个 进程拷贝到另外一个进程的，因为屏幕截图可能会包含隐私信息。

          Layer类的成员函数setBuffers接下来又检查要创建的Surface的像素格式的Alpha通道的高8位是否大于低8位。如果是的话，就将成员变量mNeedsBlending的值设置为true，表示在渲染时要执行混合操作。

          Layer类的成员函数setBuffers接下来还检查要创建的Surface的像素格式的Red通道的大小是否大于系统第1个显示屏的像素格式的 Red通道的大小。如果是的话，就将成员变量mNeedsDithering的值设置为true，表示在渲染时要执行抖动操作。

          最后，Layer类的成员函数setBuffers就创建了一个SurfaceLayer对象，并且保存成员变量mSurface中。

          接下来，我们就继续分析SurfaceLayer对象的创建过程。

          Step 7. new SurfaceLayer

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. Layer::SurfaceLayer::SurfaceLayer(const sp<SurfaceFlinger>& flinger,  
    2.         const sp<Layer>& owner)  
    3.     : Surface(flinger, owner->getIdentity(), owner)  
    4. {  
    5. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

           SurfaceLayer类的构造函数的实现很简单，它只是使用参数flinger以及owner来初始其父类Surface，其中，参数flinger 指向的是SurfaceFlinger服务，而参数owner指向的是正在创建的SurfaceLayer对象的宿主Layer对象。

           这一步执行完成之后，  沿着调用路径返回到SurfaceFlinger类的成员函数createSurface中，这时候就创建好一个Layer对象及其内部的一个 SurfaceLayer对象了，接下来，我们继续分析SurfaceFlinger类的成员函数addClientLayer的实现，以便可以了解 SurfaceFlinger服务是如何维护它所创建的Layer的，即它所创建的Surface。

           Step 8. SurfaceFlinger.addClientLayer

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. ssize_t SurfaceFlinger::addClientLayer(const sp<Client>& client,  
    2.         const sp<LayerBaseClient>& lbc)  
    3. {  
    4.     Mutex::Autolock _l(mStateLock);  
    5.   
    6.     // attach this layer to the client  
    7.     ssize_t name = client->attachLayer(lbc);  
    8.   
    9.     // add this layer to the current state list  
    10.     addLayer_l(lbc);  
    11.   
    12.     return name;  
    13. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

           参数client指向了一个Client对象，它是用来描述当前正在请求SurfaceFlinger服务的一个Android应用程序的；参数lbc指 向的是我们在前面Step 4中所创建的一个Layer对象。函数首先调用参数client所指向的一个Client对象的成员函数attachLayer来关联参数lbc所指向的 一个Layer对象，以表示参数lbc所指向的一个Layer对象是由参数client所指向的一个Client对象所描述的一个Android应用程序 请求创建的，接下来再调用SurfaceFlinger类的成员函数addLayer_l来将参数lbc所指向的一个Layer对象保存在 SurfaceFlinger的内部。

           接下来，我们首先分析Client类的成员函数attachLayer的实现，接着再分析SurfaceFlinger类的成员函数addLayer_l的实现。

           Step 9. Client.attachLayer

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. ssize_t Client::attachLayer(const sp<LayerBaseClient>& layer)  
    2. {  
    3.     int32_t name = android_atomic_inc(&mNameGenerator);  
    4.     mLayers.add(name, layer);  
    5.     return name;  
    6. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

           从前面Android应用程序与SurfaceFlinger服务的连接过程分析一 文可以知道，Client类的成员变量mNameGenerator是用来生成Surface名称的，它的初始值等于1，每当Android应用程序请求 SurfaceFlinger服务为它创建一个Surface，SurfaceFlinger服务就会将对应的Client对象的成员变量 mNameGenerator的值增加1，这样就可以依次得到名称等于1、2、3......的Surface。

           为正在创建的Surface生成好名称name之后，Client类的成员函数attachLayer就以变量name为关键字，将用来描述正在创建的 Surface的一个Layer对象layer保存Client类的成员变量mLayers所描述的一个Map中。从这里就可以知道，一个Android 应用程序所创建的Surface，都保存在与它所对应的一个Client对象的成员变量mLayers中。

          step 10. SurfaceFlinger.addLayer_l

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)  
    2. {  
    3.     ssize_t i = mCurrentState.layersSortedByZ.add(layer);  
    4.     return (i < 0) ? status_t(i) : status_t(NO_ERROR);  
    5. }  

          这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

          SurfaceFlinger类的成员变量mCurrentState指向了一个State对象，这个State对象内部有一个成员变量 layersSortedByZ，它用来描述一个类型为LayerVector的向量，用来保存SurfaceFlinger服务所创建的每一个 Layer，并且这些Layer是按照Z轴坐示来排列的。这样，SurfaceFlinger服务在渲染Surface的时候，就可以根据这个向量来计算 可见性。

          这一步执行完成之后，回到SurfaceFlinger类的成员函数createSurface中，这时候SurfaceFlinger服务就将前面所 创建的一个Layer对象保存好在内部了，接下来就会调用这个Layer对象的成员函数getSurface来获得在前面Step 6中所创建的一个SurfaceLayer对象，以便可以将它的一个Binder代理对象返回请求Surface的Android应用程序。

          Layer类的成员函数getSurface是从父类LayerBaseClient继承下来的，因此，接下来我们就继续分析LayerBaseClient类的成员函数getSurface的实现。

          Step 11. LayerBaseClient.getSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<LayerBaseClient::Surface> LayerBaseClient::getSurface()  
    2. {  
    3.     sp<Surface> s;  
    4.     Mutex::Autolock _l(mLock);  
    5.     s = mClientSurface.promote();  
    6.     if (s == 0) {  
    7.         s = createSurface();  
    8.         mClientSurface = s;  
    9.     }  
    10.     return s;  
    11. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/LayerBase.cpp中。

           LayerBaseClient类的成员变量mClientSurface是一个类型为Surface的弱指针，它指向了一个Surface子类对 象。函数首先将LayerBaseClient类的成员变量mClientSurface升级为一个强指针s。如果升级失败，即得到的强指针的值等于0， 那么就说明要么还没有初始化LayerBaseClient类的成员变量mClientSurface，要么LayerBaseClient类的成员变量 mClientSurface所指向的一个Surface子类对象已经被销毁了。在这种情况下，函数就会调用由其子类来重写的成员函数 createSurface来获得一个Surface子类对象，并且保存在成员变量mClientSurface中。最后再将得到的Surface子类对 象返回给调用者。弱指针升级为强指针的原理，可以参考Android系统的智能指针（轻量级指针、强指针和弱指针）的实现原理分析一文。

          在我们这个场景中，LayerBaseClient的子类即为Layer类，因此，接下来我们就继续分析它的成员函数createSurface的实现。

          Step 12. Layer.createSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<LayerBaseClient::Surface> Layer::createSurface() const  
    2. {  
    3.     return mSurface;  
    4. }  

          这个函数定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

          从前面的Step 6可以知道， Layer类的成员变量mSurface已经指向了一个SurfaceLayer对象，因此，函数就可以直接将它返回给调用者。

          这一步执行完成之后，回到SurfaceFlinger类的成员函数createSurface中，这时候SurfaceFlinger服务就完成了 Android应用程序所请求创建的Surface了，最后就会将用来描述这个Surface的一个urfaceLayer对象的一个Binder代理对 象返回Android应用程序，以便Android应用程序可以将它封装成一个SurfaceControl对象，如前面的Step 1所示。

          接下来，我们就回到Android应用程序这一侧，继续分析SurfaceControl对象的创建过程。

          Step 13. new SurfaceControl

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. SurfaceControl::SurfaceControl(  
    2.         const sp<SurfaceComposerClient>& client,  
    3.         const sp<ISurface>& surface,  
    4.         const ISurfaceComposerClient::surface_data_t& data,  
    5.         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags)  
    6.     : mClient(client), mSurface(surface),  
    7.       mToken(data.token), mIdentity(data.identity),  
    8.       mWidth(data.width), mHeight(data.height), mFormat(data.format),  
    9.       mFlags(flags)  
    10. {  
    11. }  

          这个函数定义在文件frameworks/base/libs/surfaceflinger_client/Surface.cpp中。

          SurfaceControl类的构造函数的实现很简单，它只是对各个成员变量进行初始化，其中，我们需要重点关注的是，SurfaceControl 类的成员变量mSurface指向的是一个类型为BpSurface的Binder代理对象，这个Binder代理对象引用的是由 SurfaceFlinger服务所创建的一个类型为SurfaceLayer的Binder本地对象。

          这一步执行完成之后，返回到开机动画应用程序bootanim中，即BootAnimation类的成员函数readyToRun中，接下来它就会调用 在这一步所创建的SurfaceControl对象的成员函数getSurface来获得一个Surface对象。

          接下来，我们就继续分析SurfaceControl类的成员函数getSurface的实现。

          Step 14. SurfaceControl.getSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. sp<Surface> SurfaceControl::getSurface() const  
    2. {  
    3.     Mutex::Autolock _l(mLock);  
    4.     if (mSurfaceData == 0) {  
    5.         mSurfaceData = new Surface(const_cast<SurfaceControl*>(this));  
    6.     }  
    7.     return mSurfaceData;  
    8. }  

          这个函数定义在文件frameworks/base/libs/surfaceflinger_client/Surface.cpp中。

          SurfaceControl类的成员函数getSurface第一次被调用时，成员变量mSurfaceData的值等于0，因此，函数接下来就会创建一个Surface对象，并且保存在成员变量mSurfaceData中。

          接下来，我们就继续分析Surface对象的创建过程。

          Step 15. new Surface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. Surface::Surface(const sp<SurfaceControl>& surface)  
    2.     : mBufferMapper(GraphicBufferMapper::get()),  
    3.       mClient(SurfaceClient::getInstance()),  
    4.       mSharedBufferClient(NULL),  
    5.       mInitCheck(NO_INIT),  
    6.       mSurface(surface->mSurface),  
    7.       mIdentity(surface->mIdentity),  
    8.       mFormat(surface->mFormat), mFlags(surface->mFlags),  
    9.       mWidth(surface->mWidth), mHeight(surface->mHeight)  
    10. {  
    11.     init();  
    12. }  

           这个函数定义在文件frameworks/base/libs/surfaceflinger_client/Surface.cpp中。

           Surface类的成员变量mBufferMapper指向了一个GraphicBufferMapper对象，它是用来将分配到的图形缓冲区映射到 Android应用程序进程的地址空间的，在接下来的一篇文章介绍Surface的渲染过程时，我们再详细分析。

           Surface类的成员变量mClient指向了Android应用程序进程中的一个SurfaceClient单例。从前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一 文可以知道，这个SurfaceClient单例是有来创建Android应用程序与SurfaceFlinger服务的共享UI元数据的。当 SurfaceClient类的成员函数getInstance第一次在进程中被调用时，Android应用程序便会请求SurfaceFlinger服 务创建这块共享UI元数据。

           Surface类的成员变量mSharedBufferClient指向了一个SharedBufferClient对象。文章开始时提 到，SharedBufferClient是用来在Android应用程序这一侧描述一个Surface的UI元数据缓冲区堆栈的，后面我们再分析它的创 建过程。

           Surface类的成员变量mSurface指向了一个类型为BpSurface的Binder代理对象。从Surface类的构造函数就可以看出，这个Binder代理对象引用的是在前面Step 6中创建的一个SurfaceLayer对象。

           Surface类的其余成员变量mIdentity、mFormat、mFlags、mWidth和mHeight分别用来描述一个Surface的ID、像素格式、用途、宽度和高度。

           Surface类的构造函数接下来调用另外一个成员函数init进一步执行初始化的工作，接下来，我们就继续分析Surface类的成员函数init的实现。

           Step 16. Surface.init

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. void Surface::init()  
    2. {  
    3.     ANativeWindow::setSwapInterval  = setSwapInterval;  
    4.     ANativeWindow::dequeueBuffer    = dequeueBuffer;  
    5.     ANativeWindow::cancelBuffer     = cancelBuffer;  
    6.     ANativeWindow::lockBuffer       = lockBuffer;  
    7.     ANativeWindow::queueBuffer      = queueBuffer;  
    8.     ANativeWindow::query            = query;  
    9.     ANativeWindow::perform          = perform;  
    10.   
    11.     DisplayInfo dinfo;  
    12.     SurfaceComposerClient::getDisplayInfo(0, &dinfo);  
    13.     const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi;  
    14.     const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi;  
    15.     // FIXME: set real values here  
    16.     const_cast<int&>(ANativeWindow::minSwapInterval) = 1;  
    17.     const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;  
    18.     const_cast<uint32_t&>(ANativeWindow::flags) = 0;  
    19.   
    20.     mNextBufferTransform = 0;  
    21.     mConnected = 0;  
    22.     mSwapRectangle.makeInvalid();  
    23.     mNextBufferCrop = Rect(0,0);  
    24.     // two buffers by default  
    25.     mBuffers.setCapacity(2);  
    26.     mBuffers.insertAt(0, 2);  
    27.   
    28.     if (mSurface != 0 && mClient.initCheck() == NO_ERROR) {  
    29.         int32_t token = mClient.getTokenForSurface(mSurface);  
    30.         if (token >= 0) {  
    31.             mSharedBufferClient = new SharedBufferClient(  
    32.                     mClient.getSharedClient(), token, 2, mIdentity);  
    33.             mInitCheck = mClient.getSharedClient()->validate(token);  
    34.         }  
    35.     }  
    36. }  

           这个函数定义在文件frameworks/base/libs/surfaceflinger_client/Surface.cpp中。

           这个函数的初始化工作分为两部分。

           第一部分初始化工作是与OpenGL库相关的，主要就是设置OpenGL指定的一系列回调接口，以及设置设备显示屏信息。前面提到，Surface类是从 ANativeWindow类继承下来的，作为OpenGL库与Android系统的本地窗口的连接桥梁。

           ANativeWindow类定义了setSwapInterval、dequeueBuffer、cancelBuffer、lockBuffer、 queueBuffer、query和perform一共7个回调接口，它们分别被设置为Surface类的静态成员函数 setSwapInterval、dequeueBuffer、cancelBuffer、lockBuffer、queueBuffer、query和 perform。我们主要关注dequeueBuffer和queueBuffer两个回调接口，前者用来从UI元数据缓冲区堆栈中获得一个缓冲区，而后 者用来将一个缓冲区插入到UI元数据缓冲区堆栈的待渲染队列中。在接下来的一篇文章介绍Surface的渲染过程时，我们再详细分析这两个回调接口。

          ANativeWindow类还定义了四个成员变量xdpi、ydpi、minSwapInterval、maxSwapInterval和 flags，这几个成员变量也是要由Surface类来初始化的。成员变量xdpi和ydpi用来描述设备显示度的密度，即每英寸点数。设备显示屏的密码 信息可以通过调用SurfaceComposerClient类的静态成员函数getDisplayInfo来获得。成员变量 minSwapInterval和maxSwapInterval用来描述前后两个缓冲区进行交换的最小和最大时间间隔。成员变量flags用来描述一些 标志信息。

          第二部分初始化工作是与UI元数据缓冲区相关。

          Surface类的成员变量mNextBufferTransform、mSwapRectangle和mNextBufferCrop分别用来描述下一个要渲染的图形缓冲区的旋转方向、裁剪区域和纹理坐标。

          Surface类的成员变量mBuffers用来描述一个类型为sp<GraphicBuffer>的Vector，主要是用来保存一个 Surface所使用的图形缓冲区（GraphicBuffer）的。一开始的时候，这个向量的大小被设置为2，后面会根据实际需要来增加容量。

          Surface类的成员变量mSharedBufferClient指向了一个SharedBufferClient对象，用来描述一个UI元数据缓冲区堆栈，它的创建过程是最重要的，因此，接下来我们就详细分析这个过程。

          Surface类的成员函数init首先调用成员变量mClient的成员函数getTokenForSurface来获得成员变量mSurface所 描述的一个Surface的token值。有了这个token值之后，接下就可以创建一个SharedBufferClient对象，并且保存 在 Surface类的成员变量mSharedBufferClient中了。

          在前面的Step 15中提到，Surface类的成员变量mClient指向的是一个SurfaceClient对象，因此，接下来我们首先分析 SurfaceClient类的成员函数getTokenForSurface的实现，接着再分析SharedBufferClient对象的创建过程。

          从前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一 文可以知道，SurfaceClient类的成员函数getTokenForSurface实际上是调用了其成员变量mClient所指向的一个类型为 BpSurfaceComposerClient的Binder代理对象的成员函数getTokenForSurface来请求 SurfaceFlinger服务返回一个Surface的token值。由于这个Binder代理对象引用的是一个类型为UserClient的 Binder本地对象，这个Binder本地对象是运行在SurfaceFlinger服务这一侧的。接下来，我们就直接分析UserClient类的成 员函数getTokenForSurface的实现。

          Step 17. UserClient.getTokenForSurface

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. ssize_t UserClient::getTokenForSurface(const sp<ISurface>& sur) const  
    2. {  
    3.     int32_t name = NAME_NOT_FOUND;  
    4.     sp<Layer> layer(mFlinger->getLayer(sur));  
    5.     if (layer == 0) return name;  
    6.   
    7.     // if this layer already has a token, just return it  
    8.     name = layer->getToken();  
    9.     if ((name >= 0) && (layer->getClient() == this))  
    10.         return name;  
    11.   
    12.     name = 0;  
    13.     do {  
    14.         int32_t mask = 1LU<<name;  
    15.         if ((android_atomic_or(mask, &mBitmap) & mask) == 0) {  
    16.             // we found and locked that name  
    17.             status_t err = layer->setToken(  
    18.                     const_cast<UserClient*>(this), ctrlblk, name);  
    19.             if (err != NO_ERROR) {  
    20.                 // free the name  
    21.                 android_atomic_and(~mask, &mBitmap);  
    22.                 name = err;  
    23.             }  
    24.             break;  
    25.         }  
    26.         if (++name >= SharedBufferStack::NUM_LAYERS_MAX)  
    27.             name = NO_MEMORY;  
    28.     } while(name >= 0);  
    29.   
    30.     //LOGD("getTokenForSurface(%p) => %d (client=%p, bitmap=%08lx)",  
    31.     //        sur->asBinder().get(), name, this, mBitmap);  
    32.     return name;  
    33. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

           从前面的调用过程可以知道，参数sur指向了一个SurfaceLayer对象，并且这个SurfaceLayer对象是在前面的Step 6中创建的。

           UserClient类的成员变量mFlinger指向了SurfaceFlinger服务，函数首先调用它的成员函数getLayer来获得参数sur 所指向的SurfaceLayer对象的宿主Layer对象layer，接着调用这个Layer对象layer的成员函数getToken来获得它的 token值。如果这个token值大于等于0，那么就说明已经为Layer对象layer分配过token值了，即已经为参数sur所描述的 Surface分配过token值了。在这种情况下，就直接将该token值返回给Android应用程序。否则的话，UserClient类的成员函数 getTokenForSurface接下来就需要为参数sur所描述的Surface分配一个token值。

           UserClient类的成员变量mBitmap是一个int32_t值，它是用来为Android应用程序的Surface分配Token值的，即 如果它的第n位等于1，那么就表示值等于n的Token已经被分配出去使用了。UserClient类的成员函数getTokenForSurface使 用一个while循环来在成员变量mBitmap中从低位到高位找到一个值等于0的位，接着再将位所在的位置值作为参数sur所描述的一个Surface 的token值，最后还会将这个token值设置到Layer对象layer里面去，这是通过调用Layer类的成员函数setToken来实现的。

          接下来，我们就继续分析Layer类的成员函数setToken的实现。

          Step 18. Layer.setToken

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. status_t Layer::setToken(const sp<UserClient>& userClient,  
    2.         SharedClient* sharedClient, int32_t token)  
    3. {  
    4.     sp<SharedBufferServer> lcblk = new SharedBufferServer(  
    5.             sharedClient, token, mBufferManager.getDefaultBufferCount(),  
    6.             getIdentity());  
    7.   
    8.     status_t err = mUserClientRef.setToken(userClient, lcblk, token);  
    9.   
    10.     LOGE_IF(err != NO_ERROR,  
    11.             "ClientRef::setToken(%p, %p, %u) failed",  
    12.             userClient.get(), lcblk.get(), token);  
    13.   
    14.     if (err == NO_ERROR) {  
    15.         // we need to free the buffers associated with this surface  
    16.     }  
    17.   
    18.     return err;  
    19. }  

           这个函数定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

           参数userClient指向了一个UserClient对象，而参数sharedClient指向了该UserClient对象内部的成员变量ctrlblk所指向的一个SharedClient对象。从前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文可以知道，这个SharedClient对象是用来描述一组UI元数据缓冲区堆栈的。

           Layer类的成员变量mBufferManager指向了一个BufferManager对象，通过调用它的成员函数 getDefaultBufferCount就可以获得一个UI元数据缓冲区堆栈的大小，即这个堆栈里面所包含的UI元数据缓冲区的个数。有了这些信息之 后，Layer类的成员函数setToken就可以创建一个SharedBufferServer对象lcblk了，并且会将这个 SharedBufferServer对象lcblk保存在Layer类的成员变量mUserClientRef所描述的一个ClientRef对象的内 部。这是通过调用ClientRef类的成员函数setToken来实现的，如下所示：

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. status_t Layer::ClientRef::setToken(const sp<UserClient>& uc,  
    2.         const sp<SharedBufferServer>& sharedClient, int32_t token) {  
    3.     Mutex::Autolock _l(mLock);  
    4.   
    5.     { // scope for strong mUserClient reference  
    6.         sp<UserClient> userClient(mUserClient.promote());  
    7.         if (mUserClient != 0 && mControlBlock != 0) {  
    8.             mControlBlock->setStatus(NO_INIT);  
    9.         }  
    10.     }  
    11.   
    12.     mUserClient = uc;  
    13.     mToken = token;  
    14.     mControlBlock = sharedClient;  
    15.     return NO_ERROR;  
    16. }  

          这个函数同样是定义在文件frameworks/base/services/surfaceflinger/Layer.cpp中。

          ClientRef类有三个成员变量mUserClient、mToken和mControlBlock。其中，mUserClient是一个类型为 UserClient的弱指针，它指向了参数uc所描述的一个UserClient对象，mToken是一个int32_t值，用来描述它的宿主 Layer对象的token值，mControlBlock是一个类型为SharedBufferServer强指针，它指向了参数 sharedCient所描述一个haredBufferServer对象，用来在SurfaceFlinger服务这一侧描述一个UI元数据缓冲区堆 栈。

         回到Layer类的成员函数setToken中，接下来我们继续分析一个SharedBufferServer对象的创建过程。

         Step 19. new SharedBufferServer

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. SharedBufferServer::SharedBufferServer(SharedClient* sharedClient,  
    2.         int surface, int num, int32_t identity)  
    3.     : SharedBufferBase(sharedClient, surface, identity),  
    4.       mNumBuffers(num)  
    5. {  
    6.     mSharedStack->init(identity);  
    7.     mSharedStack->token = surface;  
    8.     mSharedStack->head = num-1;  
    9.     mSharedStack->available = num;  
    10.     mSharedStack->queued = 0;  
    11.     mSharedStack->reallocMask = 0;  
    12.     memset(mSharedStack->buffers, 0, sizeof(mSharedStack->buffers));  
    13.     for (int i=0 ; i<num ; i++) {  
    14.         mBufferList.add(i);  
    15.         mSharedStack->index[i] = i;  
    16.     }  
    17. }  

           这个函数定义在文件frameworks/base/libs/surfaceflinger_client/SharedBufferStack.cpp中。

           SharedBufferServer类的构造函数主要是用来初始它所描述的一个UI元数据缓冲区堆栈的，这个UI元数据缓冲区堆栈是通过其父类的成 员变量mSharedStack所指向的一个SharedBufferStack对象来描述的。SharedBufferStack类的各个成员变量的含 义可以参考前面前面Android应用程序与SurfaceFlinger服务之间的共享UI元数据（SharedClient）的创建过程分析一文，这里不再复述。

           这一步执行完成之后，沿着调用路径，一直返回到前面的Step 16中，即Surface类的成员函数init中，这时候Android应用程序就获得了正在创建的Surface的token值，接下来就可以以这个 token值为参数，来创建一个SharedBufferClient对象了。

           Step 20. new SharedBufferClient

    [cpp] view plaincopy在CODE上查看代码片派生到我的代码片
    1. SharedBufferClient::SharedBufferClient(SharedClient* sharedClient,  
    2.         int surface, int num, int32_t identity)  
    3.     : SharedBufferBase(sharedClient, surface, identity),  
    4.       mNumBuffers(num), tail(0)  
    5. {  
    6.     SharedBufferStack& stack( *mSharedStack );  
    7.     tail = computeTail();  
    8.     queued_head = stack.head;  
    9. }  

           这个函数定义在文件frameworks/base/libs/surfaceflinger_client/SharedBufferStack.cpp中。

           SharedBufferClient类的构造函数主要是用来初始化成员变量tail和queued_head的值。这两个成员变量的含义可以参考前 面Android应用程序与SurfaceFlinger服务的关系概述和学习计划一文中的图6，这里不再详述。

           这里我们需要注意的是，这里的参数sharedClient指向了一个SharedClient对象，这个SharedClient对象与在前面Step 18中用来创建SharedBufferServer对象的SharedClient对象描述的是同一块匿名共享内存，而且这里的参数surface与在 前面Step 18中用来创建SharedBufferServer对象的token的值是相等的，这意味着这一步所创建的SharedBufferClient对象与 前面Step 19所创建的SharedBufferServer对象描述的是同一个SharedBufferStack对象，即同一个UI元数据缓冲区堆栈，并且这个 UI元数据缓冲区堆栈已经在前面的Step 19中初始化好了。

           至此，Android应用程序请求SurfaceFlinger服务创建Surface的过程就分析完成了。我们需要重点掌握的是，当Android应用 程序请求SurfaceFlinger服务创建一个Surface的时候，需要在SurfaceFlinger服务这一侧创建一个Layer对象、一个 Layer::SurfaceLayer对象和一个SharedBufferServer对象，同时又需要在Android应用程序这一侧创建一个 SurfaceControl对象、一个Surface对象和一个SharedBufferClient对象。掌握了这些知识之后，在接下来的一篇文章 中，我们就可以分析Android应用程序请求SurfaceFlinger服务渲染Surface的过程了，敬请期待！

    老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！
  • 相关阅读:
    JeeSite 部署到linux服务器
    Linux下安装Tomcat
    linux下执行sh脚本，提示Command not found解决办法
    PHP no input file specified 三种解决方法
    1286 unknown storage engine innodb
    php 部署在iis HTTP 错误 500.0
    老黄历接口（免注册）
    未来世界的幸存者
    Kafka流处理平台
    首次启动Kafka报Java HotSpot(TM) 64-Bit Server VM warning: INFO: os::commit_memory(0x00000000c0000000, 1073741824, 0) failed; error='Cannot allocate memory' (errno=12)
  • 原文地址：https://www.cnblogs.com/Free-Thinker/p/4142600.html
Copyright © 2011-2022 走看看