程序博客网 > 手机彩票计划软件

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

来源：互联网 发布：手机彩票计划软件 编辑：程序博客网 时间：2024/04/30 10:02

  前面我们已经学习过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的过程了，敬请期待！

0 0
手机彩票计划软件 手机彩票计划软件
原创粉丝点击
热门IT博客
法蒂玛预言 知乎法蒂玛预言 知乎
淘宝语嫣淘宝语嫣
中国软件登记中心
巨人网络开发的游戏
拜拉席恩家族知乎
poi软件
论文图是用什么软件
线切割手动编程
ubuntu tar.gz 压缩
windows iis限制
生成木马软件下载
华为亲子是什么软件
void在c语言中什么意思
华为停用移动数据
图像对比度算法
shopnc软件版权问题
生成式对抗网络原理
最好的网络医院平台
仁化政府网络问政平台
无间道剧情全解析 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 有眼蛋怎么办 眼上长眼蛋怎么办 微信没掉怎么办 贵宾卡怎么办 上扣鞋鞋总掉怎么办 卖家千牛被禁言怎么办 魔战耗蓝怎么办 云闪付会闪退怎么办 九游充错钱怎么办 小黑裤起筋怎么办 缸壁爆藻怎么办 微信充到空号怎么办 微信扫码没到账怎么办 手游充钱没到账怎么办 半屏钢化膜白边怎么办 摩拜没关锁怎么办 软胶壳变黄怎么办 钢化膜有泡怎么办 贴膜有白边怎么办 贴膜白边怎么办 魅族重启怎么办 土培红掌烂根怎么办 红掌烂根怎么办 红掌烂根修完怎么办 哈曼卡顿进灰怎么办 刷漆有刷痕怎么办 天猫魔盒灯不亮怎么办 花呗乱扣费怎么办 盗图被骂怎么办 百香果皱皮怎么办 慕课网课没上完怎么办 楚留香闪退怎么办 怎么办天悦卡 耐克官网售假怎么办 优看阁打不开怎么办 充值卡怎么办 怎么办会员卡 天颐佳苑怎么办 苏宁易购黑号怎么办 苏宁易购怎么办 韵达掉件怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里