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

分类： Android 2012-09-03 01:01 11197人阅读 评论(31) 收藏 举报

前面我们已经学习过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 plain copy print ?
  1. classISurface:publicIInterface
  2. {
  3. ......
  5. public:
  6. DECLARE_META_INTERFACE(Surface);
  8. /*
  9. *requestsanewbufferforthegivenindex.Ifw,h,orformatare
  10. *nullthebufferiscreatedwiththeparametersassignedtothe
  11. *surfaceitisboundto.Otherwisethebuffer'sparametersare
  12. *settothosespecified.
  13. */
  14. virtualsp<GraphicBuffer>requestBuffer(intbufferIdx,
  15. uint32_tw,uint32_th,uint32_tformat,uint32_tusage)=0;
  17. ......
  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 plain copy print ?
  1. SharedBufferBase::SharedBufferBase(SharedClient*sharedClient,
  2. intsurface,int32_tidentity)
  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 plain copy print ?
  1. classSharedBufferServer
  2. :publicSharedBufferBase,
  3. publicLightRefBase<SharedBufferServer>
  4. {
  5. ......
  7. private:
  8. ......
  10. /*
  11. *BufferListisbasicallyafixed-capacitysorted-vectorof
  12. *unsigned5-bitsintsusinga32-bitsintasstorage.
  13. *ithasefficientiteratorstofinditemsinthelistandnotinthelist.
  14. */
  15. classBufferList{
  16. size_tmCapacity;
  17. uint32_tmList;
  18. public:
  19. BufferList(size_tc=SharedBufferStack::NUM_BUFFER_MAX)
  20. :mCapacity(c),mList(0){}
  21. status_tadd(intvalue);
  22. status_tremove(intvalue);
  23. uint32_tgetMask()const{returnmList;}
  25. classconst_iterator{
  26. friendclassBufferList;
  27. uint32_tmask,curr;
  28. const_iterator(uint32_tmask):
  29. mask(mask),curr(__builtin_clz(mask)){
  30. }
  31. public:
  32. inlinebooloperator==(constconst_iterator&rhs)const{
  33. returnmask==rhs.mask;
  34. }
  35. inlinebooloperator!=(constconst_iterator&rhs)const{
  36. returnmask!=rhs.mask;
  37. }
  38. inlineintoperator*()const{returncurr;}
  39. inlineconstconst_iterator&operator++(){
  40. mask&=~(1<<(31-curr));
  41. curr=__builtin_clz(mask);
  42. return*this;
  43. }
  44. };
  46. inlineconst_iteratorbegin()const{
  47. returnconst_iterator(mList);
  48. }
  49. inlineconst_iteratorend()const{
  50. returnconst_iterator(0);
  51. }
  52. inlineconst_iteratorfree_begin()const{
  53. uint32_tmask=(1<<(32-mCapacity))-1;
  54. returnconst_iterator(~(mList|mask));
  55. }
  56. };
  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 plain copy print ?
  1. status_tBootAnimation::readyToRun(){
  2. ......
  4. //createthenativesurface
  5. sp<SurfaceControl>control=session()->createSurface(
  6. getpid(),0,dinfo.w,dinfo.h,PIXEL_FORMAT_RGB_565);
  7. ......
  9. sp<Surface>s=control->getSurface();
  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 plain copy print ?
  1. sp<SurfaceControl>SurfaceComposerClient::createSurface(
  2. intpid,
  3. DisplayIDdisplay,
  4. uint32_tw,
  5. uint32_th,
  6. PixelFormatformat,
  7. uint32_tflags)
  8. {
  9. String8name;
  10. constsize_tSIZE=128;
  11. charbuffer[SIZE];
  12. snprintf(buffer,SIZE,"<pid_%d>",getpid());
  13. name.append(buffer);
  15. returnSurfaceComposerClient::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 plain copy print ?
  1. sp<SurfaceControl>SurfaceComposerClient::createSurface(
  2. intpid,
  3. constString8&name,
  4. DisplayIDdisplay,
  5. uint32_tw,
  6. uint32_th,
  7. PixelFormatformat,
  8. uint32_tflags)
  9. {
  10. sp<SurfaceControl>result;
  11. if(mStatus==NO_ERROR){
  12. ISurfaceComposerClient::surface_data_tdata;
  13. sp<ISurface>surface=mClient->createSurface(&data,pid,name,
  14. display,w,h,format,flags);
  15. if(surface!=0){
  16. result=newSurfaceControl(this,surface,data,w,h,format,flags);
  17. }
  18. }
  19. returnresult;
  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 plain copy print ?
  1. sp<ISurface>Client::createSurface(
  2. ISurfaceComposerClient::surface_data_t*params,intpid,
  3. constString8&name,
  4. DisplayIDdisplay,uint32_tw,uint32_th,PixelFormatformat,
  5. uint32_tflags)
  6. {
  7. returnmFlinger->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 plain copy print ?
  1. sp<ISurface>SurfaceFlinger::createSurface(constsp<Client>&client,intpid,
  2. constString8&name,ISurfaceComposerClient::surface_data_t*params,
  3. DisplayIDd,uint32_tw,uint32_th,PixelFormatformat,
  4. uint32_tflags)
  5. {
  6. sp<LayerBaseClient>layer;
  7. sp<LayerBaseClient::Surface>surfaceHandle;
  9. if(int32_t(w|h)<0){
  10. LOGE("createSurface()failed,worhisnegative(w=%d,h=%d)",
  11. int(w),int(h));
  12. returnsurfaceHandle;
  13. }
  15. //LOGD("createSurfaceforpid%d(%dx%d)",pid,w,h);
  16. sp<Layer>normalLayer;
  17. switch(flags&eFXSurfaceMask){
  18. caseeFXSurfaceNormal:
  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. caseeFXSurfaceBlur:
  27. layer=createBlurSurface(client,d,w,h,flags);
  28. break;
  29. caseeFXSurfaceDim:
  30. layer=createDimSurface(client,d,w,h,flags);
  31. break;
  32. }
  34. if(layer!=0){
  35. layer->initStates(w,h,flags);
  36. layer->setName(name);
  37. ssize_ttoken=addClientLayer(client,layer);
  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. }
  52. setTransactionFlags(eTransactionNeeded);
  53. }
  55. returnsurfaceHandle;
  56. }
这个函数定义在文件frameworks/base/services/surfaceflinger/SurfaceFlinger.cpp中。

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

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

[cpp] view plain copy print ?
  1. classISurfaceComposer:publicIInterface
  2. {
  3. public:
  4. ......
  6. enum{//(keepinsyncwithSurface.java)
  7. ......
  8. ePushBuffers=0x00000200,
  10. eFXSurfaceNormal=0x00000000,
  11. eFXSurfaceBlur=0x00010000,
  12. eFXSurfaceDim=0x00020000,
  13. eFXSurfaceMask=0x000F0000,
  14. };
  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 plain copy print ?
  1. sp<Layer>SurfaceFlinger::createNormalSurface(
  2. constsp<Client>&client,DisplayIDdisplay,
  3. uint32_tw,uint32_th,uint32_tflags,
  4. PixelFormat&format)
  5. {
  6. //initializethesurfaces
  7. switch(format){//TODO:takeh/wintoaccount
  8. casePIXEL_FORMAT_TRANSPARENT:
  9. casePIXEL_FORMAT_TRANSLUCENT:
  10. format=PIXEL_FORMAT_RGBA_8888;
  11. break;
  12. casePIXEL_FORMAT_OPAQUE:
  13. #ifdefNO_RGBX_8888
  14. format=PIXEL_FORMAT_RGB_565;
  15. #else
  16. format=PIXEL_FORMAT_RGBX_8888;
  17. #endif
  18. break;
  19. }
  21. #ifdefNO_RGBX_8888
  22. if(format==PIXEL_FORMAT_RGBX_8888)
  23. format=PIXEL_FORMAT_RGBA_8888;
  24. #endif
  26. sp<Layer>layer=newLayer(this,display,client);
  27. status_terr=layer->setBuffers(w,h,format,flags);
  28. if(LIKELY(err!=NO_ERROR)){
  29. LOGE("createNormalSurfaceLocked()failed(%s)",strerror(-err));
  30. layer.clear();
  31. }
  32. returnlayer;
  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 plain copy print ?
  1. Layer::Layer(SurfaceFlinger*flinger,
  2. DisplayIDdisplay,constsp<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 plain copy print ?
  1. status_tLayer::setBuffers(uint32_tw,uint32_th,
  2. PixelFormatformat,uint32_tflags)
  3. {
  4. //thissurfacespixelformat
  5. PixelFormatInfoinfo;
  6. status_terr=getPixelFormatInfo(format,&info);
  7. if(err)returnerr;
  9. //thedisplay'spixelformat
  10. constDisplayHardware&hw(graphicPlane(0).displayHardware());
  11. uint32_tconstmaxSurfaceDims=min(
  12. hw.getMaxTextureSize(),hw.getMaxViewportDims());
  14. //neverallowasurfacelargerthanwhatourunderlyingGLimplementation
  15. //canhandle.
  16. if((uint32_t(w)>maxSurfaceDims)||(uint32_t(h)>maxSurfaceDims)){
  17. returnBAD_VALUE;
  18. }
  20. PixelFormatInfodisplayInfo;
  21. getPixelFormatInfo(hw.getFormat(),&displayInfo);
  22. constuint32_thwFlags=hw.getFlags();
  24. mFormat=format;
  25. mWidth=w;
  26. mHeight=h;
  28. mReqFormat=format;
  29. mReqWidth=w;
  30. mReqHeight=h;
  32. mSecure=(flags&ISurfaceComposer::eSecure)?true:false;
  33. mNeedsBlending=(info.h_alpha-info.l_alpha)>0;
  35. //weusetheredindex
  36. intdisplayRedSize=displayInfo.getSize(PixelFormatInfo::INDEX_RED);
  37. intlayerRedsize=info.getSize(PixelFormatInfo::INDEX_RED);
  38. mNeedsDithering=layerRedsize>displayRedSize;
  40. mSurface=newSurfaceLayer(mFlinger,this);
  41. returnNO_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 plain copy print ?
  1. constGraphicPlane&LayerBase::graphicPlane(intdpy)const
  2. {
  3. returnmFlinger->graphicPlane(dpy);
  4. }
SurfaceFlinger类的成员函数graphicPlane的实现如下示：

[cpp] view plain copy print ?
  1. constGraphicPlane&SurfaceFlinger::graphicPlane(intdpy)const
  2. {
  3. LOGE_IF(uint32_t(dpy)>=DISPLAY_COUNT,"InvalidDisplayID%d",dpy);
  4. constGraphicPlane&plane(mGraphicPlanes[dpy]);
  5. returnplane;
  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 plain copy print ?
  1. Layer::SurfaceLayer::SurfaceLayer(constsp<SurfaceFlinger>&flinger,
  2. constsp<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 plain copy print ?
  1. ssize_tSurfaceFlinger::addClientLayer(constsp<Client>&client,
  2. constsp<LayerBaseClient>&lbc)
  3. {
  4. Mutex::Autolock_l(mStateLock);
  6. //attachthislayertotheclient
  7. ssize_tname=client->attachLayer(lbc);
  9. //addthislayertothecurrentstatelist
  10. addLayer_l(lbc);
  12. returnname;
  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 plain copy print ?
  1. ssize_tClient::attachLayer(constsp<LayerBaseClient>&layer)
  2. {
  3. int32_tname=android_atomic_inc(&mNameGenerator);
  4. mLayers.add(name,layer);
  5. returnname;
  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 plain copy print ?
  1. status_tSurfaceFlinger::addLayer_l(constsp<LayerBase>&layer)
  2. {
  3. ssize_ti=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 plain copy print ?
  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. returns;
  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 plain copy print ?
  1. sp<LayerBaseClient::Surface>Layer::createSurface()const
  2. {
  3. returnmSurface;
  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 plain copy print ?
  1. SurfaceControl::SurfaceControl(
  2. constsp<SurfaceComposerClient>&client,
  3. constsp<ISurface>&surface,
  4. constISurfaceComposerClient::surface_data_t&data,
  5. uint32_tw,uint32_th,PixelFormatformat,uint32_tflags)
  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 plain copy print ?
  1. sp<Surface>SurfaceControl::getSurface()const
  2. {
  3. Mutex::Autolock_l(mLock);
  4. if(mSurfaceData==0){
  5. mSurfaceData=newSurface(const_cast<SurfaceControl*>(this));
  6. }
  7. returnmSurfaceData;
  8. }
这个函数定义在文件frameworks/base/libs/surfaceflinger_client/Surface.cpp中。

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

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

Step 15. new Surface

[cpp] view plain copy print ?
  1. Surface::Surface(constsp<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 plain copy print ?
  1. voidSurface::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;
  11. DisplayInfodinfo;
  12. SurfaceComposerClient::getDisplayInfo(0,&dinfo);
  13. const_cast<float&>(ANativeWindow::xdpi)=dinfo.xdpi;
  14. const_cast<float&>(ANativeWindow::ydpi)=dinfo.ydpi;
  15. //FIXME:setrealvalueshere
  16. const_cast<int&>(ANativeWindow::minSwapInterval)=1;
  17. const_cast<int&>(ANativeWindow::maxSwapInterval)=1;
  18. const_cast<uint32_t&>(ANativeWindow::flags)=0;
  20. mNextBufferTransform=0;
  21. mConnected=0;
  22. mSwapRectangle.makeInvalid();
  23. mNextBufferCrop=Rect(0,0);
  24. //twobuffersbydefault
  25. mBuffers.setCapacity(2);
  26. mBuffers.insertAt(0,2);
  28. if(mSurface!=0&&mClient.initCheck()==NO_ERROR){
  29. int32_ttoken=mClient.getTokenForSurface(mSurface);
  30. if(token>=0){
  31. mSharedBufferClient=newSharedBufferClient(
  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 plain copy print ?
  1. ssize_tUserClient::getTokenForSurface(constsp<ISurface>&sur)const
  2. {
  3. int32_tname=NAME_NOT_FOUND;
  4. sp<Layer>layer(mFlinger->getLayer(sur));
  5. if(layer==0)returnname;
  7. //ifthislayeralreadyhasatoken,justreturnit
  8. name=layer->getToken();
  9. if((name>=0)&&(layer->getClient()==this))
  10. returnname;
  12. name=0;
  13. do{
  14. int32_tmask=1LU<<name;
  15. if((android_atomic_or(mask,&mBitmap)&mask)==0){
  16. //wefoundandlockedthatname
  17. status_terr=layer->setToken(
  18. const_cast<UserClient*>(this),ctrlblk,name);
  19. if(err!=NO_ERROR){
  20. //freethename
  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);
  30. //LOGD("getTokenForSurface(%p)=>%d(client=%p,bitmap=%08lx)",
  31. //sur->asBinder().get(),name,this,mBitmap);
  32. returnname;
  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 plain copy print ?
  1. status_tLayer::setToken(constsp<UserClient>&userClient,
  2. SharedClient*sharedClient,int32_ttoken)
  3. {
  4. sp<SharedBufferServer>lcblk=newSharedBufferServer(
  5. sharedClient,token,mBufferManager.getDefaultBufferCount(),
  6. getIdentity());
  8. status_terr=mUserClientRef.setToken(userClient,lcblk,token);
  10. LOGE_IF(err!=NO_ERROR,
  11. "ClientRef::setToken(%p,%p,%u)failed",
  12. userClient.get(),lcblk.get(),token);
  14. if(err==NO_ERROR){
  15. //weneedtofreethebuffersassociatedwiththissurface
  16. }
  18. returnerr;
  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 plain copy print ?
  1. status_tLayer::ClientRef::setToken(constsp<UserClient>&uc,
  2. constsp<SharedBufferServer>&sharedClient,int32_ttoken){
  3. Mutex::Autolock_l(mLock);
  5. {//scopeforstrongmUserClientreference
  6. sp<UserClient>userClient(mUserClient.promote());
  7. if(mUserClient!=0&&mControlBlock!=0){
  8. mControlBlock->setStatus(NO_INIT);
  9. }
  10. }
  12. mUserClient=uc;
  13. mToken=token;
  14. mControlBlock=sharedClient;
  15. returnNO_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 plain copy print ?
  1. SharedBufferServer::SharedBufferServer(SharedClient*sharedClient,
  2. intsurface,intnum,int32_tidentity)
  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(inti=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 plain copy print ?
  1. SharedBufferClient::SharedBufferClient(SharedClient*sharedClient,
  2. intsurface,intnum,int32_tidentity)
  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的过程了，敬请期待！

更多相关文章

  1. Android(安卓)IPC机制
  2. 【转载】【Android】Android(安卓)Camera 使用小结
  3. Android之Handler用法总结
  4. Android启动流程分析(十) action的执行和service的启动
  5. Android系统启动流程 -- android
  6. 理解 Android(安卓)消息机制
  7. Google Developing for Android(安卓)二 － Memory 最佳实践 // li
  8. Android中对Handle机制的理解
  9. Android属性动画ObjectAnimator源码简单分析

随机推荐

  1. Android(安卓)解决APN无权限问题
  2. Android(安卓)Developers 系列 01 - Intr
  3. Android(安卓)EditText禁止输入Emoji后设
  4. Android(安卓)GestureDetector方法详解
  5. android編譯內核模塊
  6. Android常用框架整理
  7. 锦囊篇｜一文摸懂EventBus
  8. Android(安卓)Drawable 和String 相互转
  9. android自APP打开高德，百度，腾讯地图APP调
  10. android 系统目录