Android系统的开机动画是由应用程序bootanimation来实现的，它位于/system/bin目录下，它的具体实现可以参考Android系统的开机画面显示过程分析一文。为什么要选择D m i d r = w NAndroid系统的开机动画来分析Android应用程序与SurfaceF! 6 dlinger服务的连接过程呢？首先，负责实现开机动画的应用程5 8 ; |序bootanimation也是一个Android应用程序，只不过它是使用C++语言来开发的；其次，应用程序bootanimation是与UI相关的，t E Y c即它与使用Java语言来开发的标准Android应用程序一样，都需要使用SurfaceFlT L E =inger服务来创建和渲染自己的Surface，即开机动画；第三，由于应用程序bootanimation不涉及用户输入，即不需要与用户进行交互（触摸屏、键盘等），因此它能够以最简洁的方式来体现Android应用J x 4 ? ] 3 W ~程序与SurfaceFlinger服务的关系。
从前面Android系统的开机画面显示过程分析一文可以知道，Android系统的开机动画是主要一个BootAnimation对象来实现，这个BootAnimation对象在构造的时候，会在内部创建一个SurfaceComposerClient对象来负责创建一个到SurfaceFlinger服务的连接。
BootAnimation类的构造函数实现在文件framewo= U 5 . g .rks/base/cmds/bootanimation/BootAnimation.cpp中，如下所示：
Android应用程序与Sut [ ^ ^ NrfaceFlinger服务的连接过程分析
Android系统的开机动画是由应用程序bootanimati6 M y - x w 4 Hon来实现的，它位于/ss } R _ S f E vystem/bin目录下，它的具体实现可以参考Android系统的开机画面显示过程分析一文。为什么要选择Android系统的开机动画来分析Android应用程序与SurfaceFlinger服务的连接过程呢？首先，负责实现开机动画的应用D O | / ? t % *程序) K kbootanimation也是一个Android应用程序，只不过它是使用C++语言来开发的；其次，应用程序bootaniT & - C 5mation是与UI相关的，g $ q 8 k i ) m即它与使用Java语言来开发的标准Android应用程序一样，都需要使用Su| 1 3 k , VrfaceFlinger服务来创建和渲染自己的Surface，即开机动画；第三，由于应用程序bootanimat. @ # X , #ion不涉及用户输入，即不需要与用户进行交互（触摸屏、键盘等z 9 T ），因此它能够以最简洁的方式来体现Android应用程序与SurfaceFlinger服务的关系。
从前面Android系统的开机画面显示过程分析一文可以知道，Android系统的开机动画是主要一个BootAnim, } Jation对象来实现，这个BootAnimation对象在构造的时候，会在内部创建一个SurfaceComposerClient对象来负责创建一个到1 = RSurfaceFlinger服务的连接。
BootAnU f 8 E Simation类的构造函数实现在文件frameworks/base/cmds/bootanimation/BootAnimation.cJ / } m g `pp中，如下所示：
BootAnimation::BootAnimatiX # + U I von() :+ ? o = 9 4 l u Thread(false)
{
mSession = new SurfaceComposerClient();
}
mSession是BootAnimation类的成员变量，它是一个类型为SurfaceComposerClient的强指针，即sp<SurfacW ~ R V g ! ^eComposerClient>。Android系统的智能指针的相关知识，可以参考I ; @ , u 7 ,Android系统3 7 U 1 Q # 0 E的智能指针（轻量级指针、A 2 j Y i c强指针和弱指针）的实现原理分析一文。
在SurfaceComposerClient类内部，有一个类型为sp<ISurfaceComposerClient>的成员变量mClient，如图1所示：
imag N - F Ee
SurfaceComposerClient类的成员变量mClient指向的实际上是一个类型为BpSurfK $ v X T g i -aceComposerCli8 ( gent的Binder代理对象，而这个类型为BpSurfaceComposerClient的Binder代理对象引用 W * + s . G的是一个类型为Client的Binder本地对象。在前面Android应用程序与SurD C ^ f V - | m lfaceFlinger服务的关系概述和学习计划一文中提到，类型为Client的Bi8 ; 9 b I D 1nder本地对象是由SurfaceFlinger服务来负责D p ? : E U ~创建的，并且运行在SurfaceFlinger服务中，用来代表使用SurfaceFlinger服务的一个客户端，即一个与UI相关的Andro: - : N x _ ] .id应用程序。
由于Client类和BpSurfaceComposerClient类分别是一个Binder本地对象类和一个Binder代理对象类，它们都是F H * B C )根据Android系统在应用程序框架层提供的Binder进程间通信库来实现的，它们的实现结构图分@ Z ! k E _ C别如图2和图3所示：mSession是B y , !ootAnimation类的成员变量，它是一个类型为SurfaceU . r 7ComposerClient的强指针，即sp<SurfaceComposX N z q OerClieh a 2 + ? : 7 f $nt>。And_ h 0 c R @roid系统的智能指针的相关知识，可以参L Z P j p Q考And) s s E xroid系统的智能指针（轻量级指针、强指针{ - P , o B H和弱指针）的实现原理分析一文。
在SurfaceComposerClient类内部，有一个类型为sp<ISurfaceComposerClient>的成员变量mClient5 h a，如图1所示：
SurfaceComposerClient类的成员变量mClient指向的实际上是一个类型为Bp. S z Q u LSurfaceComposerClient的Binder代理对象，而这个类型为BpSurfaceComposerClient的Binder代理对象引用r f r 0 1 T的是一5 ^ u个类型为Client的Binder本地对象。在前面Android应用程序| ] L % E C n s与SurfaceFlinger服务的关系概述和学习计划一文中提到，类型为Client的Binder本地对象是由SurfaceFlinger服务来负责创建的，并且运行在SurfaceFlinger服务中，用来代表使用SurfaceFlinger服务的一个客户端，即一个与UI相关的Android应用程序。
由于ClientP [ b &类和BpSurfaceComposerv Q 9 P qCA 8 @lient类分别是一个Binder本地对象类和一个Binder代理对象类，它们都是根据w W oAndroid系统在应用程序框架层提供的Binder进程间通信库来实现的，它们的实现结构图分别如图2和图3所示：
图2 Client类的实现结构图
图3 BpSurfaceCompo` A O = | V !serClient类的实现结构图
在图2和图3中，涉及到了比较多的BiZ 2 K c A n h v Wnder2 5 h k b ? h ?进程间通信库的类，需要读者对Android6 / z 5系统的Binder进程间通信机制有一定的理解和认识。在前面的Android进程间通信（IPC）机制Binder简要介绍和学习计划一系列文章，我们已经学习过Android系统的Binder进程间通信机制了，这里不再详述。
图2和图3给我们最重要的信息是Client类和BpSurfaceComposerClient类均实现了类型为ISurfaceComposerClient的Binder接口。ISurfaceComposerClient接口X + ? k * e f :有两个重要的成员函数getControlBlock和createSurface，它们定义在文件frameworks/base/include/surfaceflinger/ISurfaceCo6 ? n I ; e { 6mposerClient.h中，如下所示：
class ISurfaceComposerClient : public IInterface
{
publicW h 6 B U:
......
v ! / r u x $irtual sp<IMemoryHeap> getControlBlock() const = 0;
......
/*
* Requires ACCESS_SUM G @RFAE k & 8 e 9 5 @ #CE_FLINGER permit ( _ # 9 lssion
*/
virtual sp<ISurface? ! + E W k> createSurface( surface_data_t* data,
int pid,
const SS C ttG p N r , {ring8& name,
DisplayID displ~ U v 8 = Hay,
uint32_t w,
uint32_t h,
PixelFormat format,
uint3m V I /2_t= 9 , ? J d flags) = 0;
......
};
其中，成员函数getContrL t OolBlock用来获得由SurfaceFlinger服务) # i O创建的一块用来传递UI元数据的匿名共享内存，而成员函p Z D M d ?数createSurface用来请求SurfaceFlinger服务创建一个Surface.从前面Android应用程序与SurfaceFlinger服务的关系概述和学习计划一文可以知道，用来传递UI元数据的匿名共享内存最终会被结构化为一个SharedClient对象，{ 7 9 s o $ e T这个SharedClient对象在每个应用程序进程中至多存在一个。在接下来的两篇文章中，我们再详细分析ISu= ? prfaceCo: ~ K % 7mposerClient接口的成员函数getControlBlock和createq ) + 4 $ b ; ) :Surface的实现。
理解了SurfaceComposerClienV O N F P n !t、Client以及BpSurfaceComposerClient这三个类的关系之后，接下来我们就可以分析Android系统的开机动画应用程序bootanimation是如何与SurfaceFlinger服务建立连接的。
从z a | [ J O t i图1可以知道，SurfaceComposerClient类继i i J | a 9 1承了RefBase类，因此，当BootAnimationa 4 + x B & g类r - y + H Z T在构造函数创建了一个SurfaceComposerClient对象，并且将这个对象赋值给类型为sp<SurfaceCompo , FserClient>的智能指针mSession时: K 4 - I . R v，就会导致SurfaceComposerClient类的成员函数onFirstRef被调用，而SurfaceComposerClient类的成员函数onFirstRev z m C A rf在调用的过程中，就会在应用程序bootanimation与SurfaceFlinger服务建立一个连接，q E & ? & R C c t这个过程如图4所示：
图4 Android应用程序与SurfaceFlinger服务的连接过程
接下来，我们就详细分j | n析每一个步骤。
Step 1Q P J X. SurfaceComposerClient::onFirstRef
void SurfaceCop u z X X } # GmposerClient::N 2 O lonFirstRef(N . ] 0)
{
sp<ISurfaceCom! ^ W ` Y aposer> sm(getComc @ 1 } | 5 9pos* 6 o : ) E ;erService());
if (sm != 0) {
sp<ISurfaceCo= : m 6 V k -mposerClient> con/ , Xn = sm->createConnect} T R [ :ion();
if (conn != 0) {
mClient = conn;
......
mStatus = NO_ERROR;
}
}
}
SurfaceComposerCliG F 4 Y i Oent类的成员函数y I _ I * ! : @ ]onFirstRef实现在文件frameworks/base/libs/surfaceflW 2 C r P | #inger_client/SurfaceComposerClient.cpp文件中。
SurfaceComposerClient类的成员函数ge- $ {tComposerSerq d Z , 6 r _vice用来获得SurfaceFlinger服务的一个代理接口，它的实现如下所示：
sp<ISurfaceComposer> ComposerService::getCompo? f - k G Q Z bserService() {
return ComposerService::getInstance().mComposerService;
}
ComposerService类是单例模式，当我们第一次调用它的静态函数getIns2 O ] =tance的时候，它就会在构造函数中获得SurfaceFlinger服务的一个代理接口，并且保存在它的成员变量mCoI m + g OmposerService中，如下所示：
ComposeG h t X r XrService::ComposerService()
: Singleton<ComposeA ? G { W GrService>() {
conU o cst String16 name(\"SurfaceFlinger\");
while (getService(na} 7 T Bme, &mComposerS2 . ^ _ e 4ervice) != NO_ERROR) {
uO o * Dsleep(250000);
}
mServerCbl] _ P a 5 X n o XkMemory = mComposerService->getCblk();
mSey F k X r k (rverCblk = sL Y 5 (tatic_cast<surface_flinger_cblk_t volatile *>(
mServerCblkMemory->getBase());
}
在ComposerService类的构造函数中，除了会获得Surfa@ A kceFlZ h ? S 4 y 1 Qinger服务的代理接口之外，还会通过这个代g e Q n理接口的成员函数getCblk来获得一块匿名共享内存mServerCblkMemory。这块匿名共享内存是由SurfaceFlinger服务创建的，用来描述系统显示屏v G A E n j n Y的信息，例如，显示屏的个数、大小、方向、密度等等信` { Y ] p息。由于这些信息可以通过一个surface_flinger_cblk_t对象来描述，因此，ComposerService类的构造函数最后就将前面从SurfaceFlinger服务获得的一块匿名共享内存结构化为一个surf1 ) k U 4 F M t tace_flinger_cblk_t对象，并且保存在ComposerServiceF A , 4 ^类的成员变量mServerCblk中。
回到SurfaceComposerClient类的成员函数onFir1 z U r vstRef中，由于Su$ V HrfaceFlinger服务g k e O d ) ~实现了ISurfaceComposer接口，因此，我们可以将前面获得的SurfaceFlinger服务的代理接口赋值给一个类型为ISurfaceComposer的强指针sm，并且调用它的成员函数createConnection来请求SurfaceFlinger服务创建一个连接，即创建一个类型为Client的Binder对象，并且将这个Binder对象的一个代理接口conn返回来。SurfaceComposerClient类获得了SurfaceFlinger服务返回来的Client代理接口conn| N +之后，就将它保存自己的成员变量mClient中，这样开机动画应用程序bootanimation后续就可以通过它来请求SurfaceFlinger创建和渲染Surface了。
接下来，我们就继续分析5 F h W m -SurfaceFliO = w G 0 w 5nger服务的成员函数createConnection的实现，以便可以了解它是如何为Android应用程序创建一个$ t %连接的。
Step 2. SurfaceFlinger::createConnection
sp<ISurfaceComposerClient> SurfaceFlinger::cr3 i G 8 R 1 B IeateConnection()
{
sp<ISurfaceComposerClient> bclient;
sp4 e [ X d q<Cl8 E S f k K #ient> client(new Client(this));
status_t err = client->initCheck();
if (err == NO_ER$ + T @ 1ROR) {
bclient = clientw 4 g 7 t;
}
return bcls P - 7 ? l D { &ient;
}
Surfacy Q w U oeFlinger类的成员函数createConn; [ Nection` j E W实现在文件frameworks/base/K k 7 Gser0 q ; X 8 Q | } Ovices/surfaceflinger/SurfaceFlinger.cpp中，它的实现很简单，只是创建了一个类s G 3 x ] A G M Y型为Client的Binder对象client，并且获得它的一个ISurfac: u /eComposerClient接口，g G w ? 3 1 g N最后将这个ISurfaceComposerClienS 4 d C ? ) H At接口，T 3 s k Y 6 J即一个Client代理对象，返回给开机动画应用程序boA 9 k sotanimation。
接下来，我们再继Y ~ / , p续分析Clien; 7 6 G | V S 7t对象的创建过程,，即Client类的构造函数的实现。
Step 3. new Client
Client::Client(const sp<SurfaceFlinger>& flinger)
: mFlinger(flinger), mNameGeneratoj A A 6 f X g h jr(1)
{
}f Y + 8
Client7 / # V 8 N M ~ ?类有两个成员变量mFli[ 0 ` Enger和mNameGenerator，: y g h ! H它们的类型分别为sp<SurfaceFlinger>和int32_t，前者指向了SurfaceFlinger服务，而后者用来生成SurfaceFlinger服务为Android应用程序所创建的每一个Surface的名称。例如，假设一个AK K s ndroid应用程序请求SurfaceFlinger创建了两个Surface，那么第一个Surface的名称就由数字1来描述，而第二个Surface就由数字2来描述，依次类推。从前面Android应用程序与SurfaceFlinger服务的关系概述和学习计划这篇文章可以知H ~ 4 ` i道，一个Android应用程序最多可以创建31个Surface。@ ; q B
回到SurO F g i O 9 ofaceFlinger类的成员函数createConneU * P Y , c 1 R Nction中，它将一个指向了一个Client对象的5 A ,ISurfaceComposerClient接口返回到开机动画C } T S L ; E应用程序bootanimation之后，开机动画R b _ p `应用程序bootanimation就可以将它封装成一个类型为BpSurfaceComS N : : 2 . J TposerClient的Binder代理对象。
Step 4. return BpSurfaceComposerClient
类型为BpSurfaceComposerClient的Binder代理对象的封装过程实现在SurfaceFlinger服务的Binder代理对象类BpSurfaceComposer的成员函数createConnection中，如下所示：
class BpSurfaceComposer : public BpInterface<ISurfaceCompos% 0 h j 7er>
{
public:
......
virtut 6 +al sp<ISurfaceC~ * = D aomposerC0 ! % 4 + _lienC v L ` { V ` xt> createConnection& g s 1 2 G M()
{
uint32_t n;
Parcel data, reply;
data.writeInterfaceToken(IS6 H | [ [ ) a 9urfE f w *aceComposer::getInterfaceDescriptorT O 6 1 S G - %());
remote()->V p * $;transact(Bn1 V o p S C }SurfaceComposer::CREATE_CONNECTION, dat~ / h M , F *a, &reply);
return interface_cas! # ~ 4 b Ft<ISurfaceComposerClient>O i 7 A ) R `(reply.readStrongBinder()3 N { S p);
}
.....i z T M.
}
interface_cast是一个T u z x 5 h S 0模板函数，它定义在framework/base/include/b * K q } Ainder/IInterface.h文件中：
template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
return INTERFACE::asInterface(obj);
}
从这里就可以看出，当模板参数为ISurfaceComposerClient的时候，模板函数inm U | { `terface_cast实际就是通过调用ISZ H L v L gurfaceComposerClient类的静态成员函数asInterface来将参数obj所描述的一个Binder代理对象，即一个BpBinder对象，封装成一个BpSurfaceComposerClient对象。
ISurfaceComposerClient类的静态成员函数asInterface是由frameworks/base] S @ k S a ( h ,/libs/surfaceflinger_client/ISurfaceComposerClient.cpp文件中的IMPLEMENT_META_INTERFACE宏来定义的，如下所示：
IMPLEMENT_ME: F W B Z 9 N DTA_INTERFACE(SurfaceComposerCl 1 p @ k b T O ,ient, \"u ? D ! ^ x _android.ui.ISurfaceComposerClient\");
IMPLEMENT_META_INTERFACE宏展开后，得到ISurfaceComposerClient类的静态成员, O y ? M W [ o函数asInterface的实现如下所示：
android::sp<ISurfaceComposerCli& ` q J yent> ISurfaceComposerClient::asInterface(const android::sp<android::IB. e | h & u hinder>& obj) {
android::s| 1 ep<ISurfaceComposerClient> intr;
if (oK D U X |bj != NULL) {
intr = static_cast&d # M slt;ISurfaceComposerClient*&e & ) 7gt. p %;(, s H i c 6 V m
obj->queryLo$ Q ` R G tcalInterfac# X f W 7 ne(ISurfaceComposerClient::descriptor).gy _ + x t uet());
if (intr == NULL) {
intr =O ` 5 C z 4 1 new BpSurfaceComposerClient(obj);
}
｝
return intr;
}
参数obj是从BpSurfaceComposer类的8 ; 4 X成员函数createConne0 5 ) Z p @ction传进来的，它指向的实际上是一个BpBinder对象。当我H x X n F ~ h们调用一个BpBinder对象的成员函数O ` C w g W K ! dqueryLocalInterface时，获i 3 5 8 # L ? w得的是一个NULL指针，因此，ISurfaceComposerCli! 9 = V %ent类的静态成员函数asInterface最后就会将参数obj所指向的一个BpBinder对象封装成一个q T E $ { ( j .BpSurfaceComposerClient对象，并且返回给调用者。
BpSurfaceComposerClieI 8 1 Qnt对象W j ] H的更具体封5 . ^ q E装过程8 B U可以参考前面浅谈Android系统进程间通信（IPC）机制Binder中的Server和Client获得Service Manager接口之路一文中所描述的BpServiceManager对象的封装过程。- ^ & 2
至此，开机动画应用程序bol F D 0 ,otaniP T ( Q b }mation就通过SurfaceComposerClient类来与SurfaceFlinger服务y z ^ * - / @ w %建立一个连接了。