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

时间:2022-09-14 10:39:29

文章转载至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所示。

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

图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所示。

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

图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,如下所示:

  1. class ISurface : public IInterface
  2. {
  3. ......
  4. public:
  5. DECLARE_META_INTERFACE(Surface);
  6. /*
  7. * requests a new buffer for the given index. If w, h, or format are
  8. * null the buffer is created with the parameters assigned to the
  9. * surface it is bound to. Otherwise the buffer's parameters are
  10. * set to those specified.
  11. */
  12. virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,
  13. uint32_t w, uint32_t h, uint32_t format, uint32_t usage) = 0;
  14. ......
  15. };

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

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

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

图3 BpSurface类的实现

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

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

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

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

图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所示。

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

图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文件中,如下所示:

  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,如下所示。

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

图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,如下所示。

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

图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文件中,如下所示:

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

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的,如下所示:

  1. status_t BootAnimation::readyToRun() {
  2. ......
  3. // create the native surface
  4. sp<SurfaceControl> control = session()->createSurface(
  5. getpid(), 0, dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
  6. ......
  7. sp<Surface> s = control->getSurface();
  8. ......
  9. }

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所示。

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

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

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

Step 1. SurfaceComposerClient.createSurface

  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. return SurfaceComposerClient::createSurface(pid, name, display,
  15. w, h, format, flags);
  16. }

这个函数定义在文件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,如下所示:

  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

  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

  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. if (int32_t(w|h) < 0) {
  9. LOGE("createSurface() failed, w or h is negative (w=%d, h=%d)",
  10. int(w), int(h));
  11. return surfaceHandle;
  12. }
  13. //LOGD("createSurface for pid %d (%d x %d)", pid, w, h);
  14. sp<Layer> normalLayer;
  15. switch (flags & eFXSurfaceMask) {
  16. case eFXSurfaceNormal:
  17. if (UNLIKELY(flags & ePushBuffers)) {
  18. layer = createPushBuffersSurface(client, d, w, h, flags);
  19. } else {
  20. normalLayer = createNormalSurface(client, d, w, h, flags, format);
  21. layer = normalLayer;
  22. }
  23. break;
  24. case eFXSurfaceBlur:
  25. layer = createBlurSurface(client, d, w, h, flags);
  26. break;
  27. case eFXSurfaceDim:
  28. layer = createDimSurface(client, d, w, h, flags);
  29. break;
  30. }
  31. if (layer != 0) {
  32. layer->initStates(w, h, flags);
  33. layer->setName(name);
  34. ssize_t token = addClientLayer(client, layer);
  35. surfaceHandle = layer->getSurface();
  36. if (surfaceHandle != 0) {
  37. params->token = token;
  38. params->identity = surfaceHandle->getIdentity();
  39. params->width = w;
  40. params->height = h;
  41. params->format = format;
  42. if (normalLayer != 0) {
  43. Mutex::Autolock _l(mStateLock);
  44. mLayerMap.add(surfaceHandle->asBinder(), normalLayer);
  45. }
  46. }
  47. setTransactionFlags(eTransactionNeeded);
  48. }
  49. return surfaceHandle;
  50. }

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

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

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

  1. class ISurfaceComposer : public IInterface
  2. {
  3. public:
  4. ......
  5. enum { // (keep in sync with Surface.java)
  6. ......
  7. ePushBuffers        = 0x00000200,
  8. eFXSurfaceNormal    = 0x00000000,
  9. eFXSurfaceBlur      = 0x00010000,
  10. eFXSurfaceDim       = 0x00020000,
  11. eFXSurfaceMask      = 0x000F0000,
  12. };
  13. ......
  14. };

回到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

  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. #ifdef NO_RGBX_8888
  21. if (format == PIXEL_FORMAT_RGBX_8888)
  22. format = PIXEL_FORMAT_RGBA_8888;
  23. #endif
  24. sp<Layer> layer = new Layer(this, display, client);
  25. status_t err = layer->setBuffers(w, h, format, flags);
  26. if (LIKELY(err != NO_ERROR)) {
  27. LOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err));
  28. layer.clear();
  29. }
  30. return layer;
  31. }

这个函数定义在文件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

  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

  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. // the display's pixel format
  9. const DisplayHardware& hw(graphicPlane(0).displayHardware());
  10. uint32_t const maxSurfaceDims = min(
  11. hw.getMaxTextureSize(), hw.getMaxViewportDims());
  12. // never allow a surface larger than what our underlying GL implementation
  13. // can handle.
  14. if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {
  15. return BAD_VALUE;
  16. }
  17. PixelFormatInfo displayInfo;
  18. getPixelFormatInfo(hw.getFormat(), &displayInfo);
  19. const uint32_t hwFlags = hw.getFlags();
  20. mFormat = format;
  21. mWidth  = w;
  22. mHeight = h;
  23. mReqFormat = format;
  24. mReqWidth = w;
  25. mReqHeight = h;
  26. mSecure = (flags & ISurfaceComposer::eSecure) ? true : false;
  27. mNeedsBlending = (info.h_alpha - info.l_alpha) > 0;
  28. // we use the red index
  29. int displayRedSize = displayInfo.getSize(PixelFormatInfo::INDEX_RED);
  30. int layerRedsize = info.getSize(PixelFormatInfo::INDEX_RED);
  31. mNeedsDithering = layerRedsize > displayRedSize;
  32. mSurface = new SurfaceLayer(mFlinger, this);
  33. return NO_ERROR;
  34. }

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

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

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

  1. const GraphicPlane& LayerBase::graphicPlane(int dpy) const
  2. {
  3. return mFlinger->graphicPlane(dpy);
  4. }

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

  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

  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

  1. ssize_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
  2. const sp<LayerBaseClient>& lbc)
  3. {
  4. Mutex::Autolock _l(mStateLock);
  5. // attach this layer to the client
  6. ssize_t name = client->attachLayer(lbc);
  7. // add this layer to the current state list
  8. addLayer_l(lbc);
  9. return name;
  10. }

这个函数定义在文件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

  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

  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

  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

  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

  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

  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

  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

  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. DisplayInfo dinfo;
  11. SurfaceComposerClient::getDisplayInfo(0, &dinfo);
  12. const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi;
  13. const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi;
  14. // FIXME: set real values here
  15. const_cast<int&>(ANativeWindow::minSwapInterval) = 1;
  16. const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
  17. const_cast<uint32_t&>(ANativeWindow::flags) = 0;
  18. mNextBufferTransform = 0;
  19. mConnected = 0;
  20. mSwapRectangle.makeInvalid();
  21. mNextBufferCrop = Rect(0,0);
  22. // two buffers by default
  23. mBuffers.setCapacity(2);
  24. mBuffers.insertAt(0, 2);
  25. if (mSurface != 0 && mClient.initCheck() == NO_ERROR) {
  26. int32_t token = mClient.getTokenForSurface(mSurface);
  27. if (token >= 0) {
  28. mSharedBufferClient = new SharedBufferClient(
  29. mClient.getSharedClient(), token, 2, mIdentity);
  30. mInitCheck = mClient.getSharedClient()->validate(token);
  31. }
  32. }
  33. }

这个函数定义在文件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

  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. // if this layer already has a token, just return it
  7. name = layer->getToken();
  8. if ((name >= 0) && (layer->getClient() == this))
  9. return name;
  10. name = 0;
  11. do {
  12. int32_t mask = 1LU<<name;
  13. if ((android_atomic_or(mask, &mBitmap) & mask) == 0) {
  14. // we found and locked that name
  15. status_t err = layer->setToken(
  16. const_cast<UserClient*>(this), ctrlblk, name);
  17. if (err != NO_ERROR) {
  18. // free the name
  19. android_atomic_and(~mask, &mBitmap);
  20. name = err;
  21. }
  22. break;
  23. }
  24. if (++name >= SharedBufferStack::NUM_LAYERS_MAX)
  25. name = NO_MEMORY;
  26. } while(name >= 0);
  27. //LOGD("getTokenForSurface(%p) => %d (client=%p, bitmap=%08lx)",
  28. //        sur->asBinder().get(), name, this, mBitmap);
  29. return name;
  30. }

这个函数定义在文件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

  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. status_t err = mUserClientRef.setToken(userClient, lcblk, token);
  8. LOGE_IF(err != NO_ERROR,
  9. "ClientRef::setToken(%p, %p, %u) failed",
  10. userClient.get(), lcblk.get(), token);
  11. if (err == NO_ERROR) {
  12. // we need to free the buffers associated with this surface
  13. }
  14. return err;
  15. }

这个函数定义在文件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来实现的,如下所示:

  1. status_t Layer::ClientRef::setToken(const sp<UserClient>& uc,
  2. const sp<SharedBufferServer>& sharedClient, int32_t token) {
  3. Mutex::Autolock _l(mLock);
  4. { // scope for strong mUserClient reference
  5. sp<UserClient> userClient(mUserClient.promote());
  6. if (mUserClient != 0 && mControlBlock != 0) {
  7. mControlBlock->setStatus(NO_INIT);
  8. }
  9. }
  10. mUserClient = uc;
  11. mToken = token;
  12. mControlBlock = sharedClient;
  13. return NO_ERROR;
  14. }

这个函数同样是定义在文件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

  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

  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,欢迎关注!

Android应用程序请求SurfaceFlinger服务创建Surface的过程分析的更多相关文章

  1. Android应用程序请求SurfaceFlinger服务渲染Surface的过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/7932268 在前面一篇文章中,我们分析了And ...

  2. Android应用程序与SurfaceFlinger服务之间的共享UI元数据(SharedClient)的创建过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/7867340 在前面一篇文章中,我们分析了And ...

  3. &lbrack;转&rsqb; Android应用程序与SurfaceFlinger服务的关系概述和学习计划

    转自:Android应用程序与SurfaceFlinger服务的关系概述和学习计划 SurfaceFlinger服务负责绘制Android应用程序的UI,它的实现相当复杂,要从正面分析它的实现不是一件 ...

  4. Android应用程序与SurfaceFlinger服务的连接过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/7857163 前文在描述Android应用程序和 ...

  5. Android应用程序与SurfaceFlinger服务的关系概述和学习计划

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/7846923 SurfaceFlinger服务负 ...

  6. Android应用程序发送广播(sendBroadcast)的过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/6744448 前面我们分析了Android应用程 ...

  7. Android应用程序窗体View的创建过程

    View类是android中非常重要的一个类.view是应用程序界面的直观体现,我们看到的应用程序界面就能够看作是View(视图)组成的. 那么我们应用程序的界面是怎么创建的呢,也就是应用程序的Vie ...

  8. &lbrack;转&rsqb;Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划

    转自:Android系统Surface机制的SurfaceFlinger服务简要介绍和学习计划 前面我们从Android应用程序与SurfaceFlinger服务的关系出发,从侧面简单学习了Surfa ...

  9. Android应用程序窗口(Activity)的绘图表面(Surface)的创建过程分析

    文章转载至CSDN社区罗升阳的安卓之旅,原文地址:http://blog.csdn.net/luoshengyang/article/details/8303098 在前文中,我们分析了应用程序窗口连 ...

随机推荐

  1. PBR

    https://iwantthatcake.wordpress.com/2012/02/22/real-time-radiosity-geometrics-enlighten/ http://www. ...

  2. C 运算符优先级

    优先级 运算符 名称或含义 使用形式 结合方向 说明 1 [] 数组下标 数组名[常量表达式] 左到右   () 圆括号 (表达式)/函数名(形参表)   . 成员选择(对象) 对象.成员名   -& ...

  3. Hadoop实战第一篇

    前言:  都说现在是草根为尊的时代,近年来hadoop及spark技术在国内越来越流行.而且渐渐现成为企业的新宠.在DT时代全面来临之前,能提早接触大数据的技术必然能先人一步.本文作为Hadoop系列 ...

  4. php缓存小技巧

    1.缓存数组到文件: <?php $arr = array(2,3,5,76,7,8,22); $data = "<?php\nreturn ".var_export( ...

  5. js后缀判断

    var extension=fileName.substring(fileName.lastIndexOf('.')+1);

  6. Bootstrap 前端框架 遇到的问题 解决方案

    bootstrap实现导航栏的响应式布局,当在小屏幕.手机屏幕浏览时自动折叠隐藏 直接放代码,更容易理解.下次可以套这个代码 <!DOCTYPE html> <html> &l ...

  7. MathType7&period;X链接:https&colon;&sol;&sol;pan&period;baidu&period;com&sol;s&sol;1rQ5Cwk5&lowbar;CC9UgvgaYPVCCg 提取码:6ojq 复制这段内容后打开百度网盘手机App,操作更方便哦完美解压,无限使用

    最近在写论文的过程中使用到了MathType,但是由于MathType30天使用已经过期,有些特殊符号用不了,于是开始找各种破解版.好吧,花了整整两个小时才算搞定,真是一部血泪史,现在把安装破解教程贴 ...

  8. C语言在宏定义中使用语句表达式和预处理器运算符

    语句表达式的亮点在于定义复杂功能的宏.使用语句表达式来定义宏,不仅可以实现复杂的功能,而且还能避免宏定义带来的歧义和漏洞.下面以一个简单的最小值的宏为例子一步步说明. 1.灰常简单的么,使用条件运算符 ...

  9. 什么是词性标注(POS tagging)

    词性标注也叫词类标注,POS tagging是part-of-speech tagging的缩写. *对POS Tagging的定义: In corpus linguistics, part-o ...

  10. &lbrack;vue&rsqb;组件的创建&lpar;componet&rpar;和销毁&lpar;keep-alive缓存&rpar;和父子dom同步nextTick

    思路: 1. 组件的好处,重用性 2. 组件对的slot用法 3. 子如何调用父的数据 4. 子如何触发父的方法执行 5. 父如何触发子的方法执行 6. 如何创建组件和销毁自建--如何缓存避免每次切换 ...