android系统的开机动画可分为三个部分，kernel启动，init进程启动，android系统服务启动。这三个开机动画都是在一个叫做 帧缓冲区（frame buffer）的硬件设备上进行渲染绘制的。
在Linux内核中，每一个硬件设备都有一个主设备号和一个从设备号，它们用来唯一地标识一个硬件设备。对于帧缓冲区硬件设备来说，它们的主设备号定义为FB_MAJOR（29），而从设备号则与注册的顺序有关，它们的值依次等于0，1，2等。
每一个被注册的帧缓冲区硬件设备在/dev/graphics目录下都有一个对应的设备文件fb<minor>，其中，<minor>表示一个从设备号。例如，第一个被注册的帧缓冲区硬件设备在/dev/graphics目录下都有一个对应的设备文件fb0。用户空间的应用程序通过这个
设备文件就可以操作帧缓冲区硬件设备了，即将要显示的画面渲染到帧缓冲区硬件设备上去
一.kernel启动动画：
kernel的启动画面在一般的android系统里面都是没有出现的，在kernel的config里面有这么两项：
# CONFIG_FRAMEBUFFER_CONSOLE is not set# CONFIG_LOGO is not set
我这里是没有打开的，第一个代表支持帧缓冲控制台，第二个代表显示logo。
在编译控制台的位置：
Device Drivers ---> Graphics support ---> Console display driver support ---> Framebuffer Console support
Device Drivers ---> Graphics support ---> Bootup logo
kernel中的ainimation 基本上都是在kernel/drivers/video/fbmem.c这个文件中实现。
我的kernel版本是：
VERSION = 3PATCHLEVEL = 1SUBLEVEL = 10EXTRAVERSION =NAME = "Divemaster Edition"
通过一系列的初始化和准备，最后调用kernel/drivers/video/logo.c中的fb_find_logo（...）来保存kernel 动画的内容：
const struct linux_logo * __init_refok fb_find_logo(int depth){ const struct linux_logo *logo = NULL; if (nologo) return NULL; if (depth >= 1) {#ifdef CONFIG_LOGO_LINUX_MONO /* Generic Linux logo */ logo = &logo_linux_mono;#endif#ifdef CONFIG_LOGO_SUPERH_MONO /* SuperH Linux logo */ logo = &logo_superh_mono;#endif } if (depth >= 4) {#ifdef CONFIG_LOGO_LINUX_VGA16 /* Generic Linux logo */ logo = &logo_linux_vga16;#endif#ifdef CONFIG_LOGO_BLACKFIN_VGA16 /* Blackfin processor logo */ logo = &logo_blackfin_vga16;#endif#ifdef CONFIG_LOGO_SUPERH_VGA16 /* SuperH Linux logo */ logo = &logo_superh_vga16;#endif } if (depth >= 8) {#ifdef CONFIG_LOGO_LINUX_CLUT224 /* Generic Linux logo */ logo = &logo_linux_clut224;#endif#ifdef CONFIG_LOGO_BLACKFIN_CLUT224 /* Blackfin Linux logo */ logo = &logo_blackfin_clut224;#endif#ifdef CONFIG_LOGO_DEC_CLUT224 /* DEC Linux logo on MIPS/MIPS64 or ALPHA */ logo = &logo_dec_clut224;#endif#ifdef CONFIG_LOGO_MAC_CLUT224 /* Macintosh Linux logo on m68k */ if (MACH_IS_MAC) logo = &logo_mac_clut224;#endif#ifdef CONFIG_LOGO_PARISC_CLUT224 /* PA-RISC Linux logo */ logo = &logo_parisc_clut224;#endif#ifdef CONFIG_LOGO_SGI_CLUT224 /* SGI Linux logo on MIPS/MIPS64 and VISWS */ logo = &logo_sgi_clut224;#endif#ifdef CONFIG_LOGO_SUN_CLUT224 /* Sun Linux logo */ logo = &logo_sun_clut224;#endif#ifdef CONFIG_LOGO_SUPERH_CLUT224 /* SuperH Linux logo */ logo = &logo_superh_clut224;#endif#ifdef CONFIG_LOGO_M32R_CLUT224 /* M32R Linux logo */ logo = &logo_m32r_clut224;#endif } return logo;}这个函数帧缓冲区硬件设备的颜色深度depth，以及不同的编译选项来获取内容的指针。
在kernel/include/linux/linux_logo.h中定义了这些内容结构体：
extern const struct linux_logo logo_linux_mono;extern const struct linux_logo logo_linux_vga16;extern const struct linux_logo logo_linux_clut224;extern const struct linux_logo logo_blackfin_vga16;extern const struct linux_logo logo_blackfin_clut224;extern const struct linux_logo logo_dec_clut224;extern const struct linux_logo logo_mac_clut224;extern const struct linux_logo logo_parisc_clut224;extern const struct linux_logo logo_sgi_clut224;extern const struct linux_logo logo_sun_clut224;extern const struct linux_logo logo_superh_mono;extern const struct linux_logo logo_superh_vga16;extern const struct linux_logo logo_superh_clut224;extern const struct linux_logo logo_m32r_clut224;extern const struct linux_logo logo_spe_clut224;
这些结构体变量保存kernel/drivers/video/logo/下的 ***.ppm 以及.pbm的文件内容。
通过logo指针保存了动画内容之后往后走就要来渲染了，调用到fbmem.c中的：
int fb_show_logo(struct fb_info *info, int rotate){ int y; y = fb_show_logo_line(info, rotate, fb_logo.logo, 0, num_online_cpus()); y = fb_show_extra_logos(info, y, rotate); return y;}同一个文件往下走调用到：
static void fb_do_show_logo(struct fb_info *info, struct fb_image *image, int rotate, unsigned int num){ unsigned int x; if (rotate == FB_ROTATE_UR) { for (x = 0; x < num && image->dx + image->width <= info->var.xres; x++) { info->fbops->fb_imageblit(info, image); image->dx += image->width + 8; } } else if (rotate == FB_ROTATE_UD) { for (x = 0; x < num && image->dx >= 0; x++) { info->fbops->fb_imageblit(info, image); image->dx -= image->width + 8; } } else if (rotate == FB_ROTATE_CW) { for (x = 0; x < num && image->dy + image->height <= info->var.yres; x++) { info->fbops->fb_imageblit(info, image); image->dy += image->height + 8; } } else if (rotate == FB_ROTATE_CCW) { for (x = 0; x < num && image->dy >= 0; x++) { info->fbops->fb_imageblit(info, image); image->dy -= image->height + 8; } }}其中：FB_ROTATE_UR 正常显示
FB_ROTATE_UD 上下倒置
FB_ROTATE_CW 顺时针转90度
FB_ROTATE_CCW 逆时针转90度
到这里就开始调用帧缓冲区硬件设备渲染指定的图像。
二.init进程启动动画：
init进程的启动又要从android下的/system/core/init/init.c的main函数开始了：
int main(int argc, char **argv){int fd_count = 0;struct pollfd ufds[4];char *tmpdev;char* debuggable;char tmp[32];int property_set_fd_init = 0;int signal_fd_init = 0;int keychord_fd_init = 0;bool is_charger = false;if (!strcmp(basename(argv[0]), "ueventd"))return ueventd_main(argc, argv);if (!strcmp(basename(argv[0]), "watchdogd"))return watchdogd_main(argc, argv);...queue_builtin_action(console_init_action, "console_init");...}这里会根据传进来的参数argv[0]判断进程名，因为首先启动的是init进程，之后会根据init.rc配置ueventd以及watchogd等进程，在这里，这两个进程加载的执行文件也是从这个init文件开始会以这个main函数为入口，所以加了判别。
在这里向init进程的action执行队列添加了一个console_init_action的action，init进程执行相应操作，具体可查看http://blog.csdn.net/jscese/article/details/18700903，最后依次执行action队列，执行同文件下的：
static int console_init_action(int nargs, char **args){ int fd; char tmp[PROP_VALUE_MAX]; if (console[0]) { snprintf(tmp, sizeof(tmp), "/dev/%s", console); console_name = strdup(tmp); } fd = open(console_name, O_RDWR); if (fd >= 0) have_console = 1; close(fd); if( load_565rle_image(INIT_IMAGE_FILE) ) { fd = open("/dev/tty0", O_WRONLY); if (fd >= 0) { const char *msg; msg = "\n" "\n" "\n" "\n" "\n" "\n" "\n" // console is 40 cols x 30 lines "\n" "\n" "\n" "\n" "\n" "\n" "\n" " A N D R O I D "; write(fd, msg, strlen(msg)); close(fd); } } return 0;}初始化控制台，通过dev/console设备来访问控制台，如果有的话 have_console 全局变量被设置为1.
开始加载显示init进程的动画，通过load_565rle_image(INIT_IMAGE_FILE）函数，INIT_IMAGE_FILE 宏定义指定动画内容位置，定义在init.h中
#define INIT_IMAGE_FILE "/initlogo.rle"
实现在/system/core/init/logo.c中：
int load_565rle_image(char *fn){ struct FB fb; struct stat s; unsigned short *data, *bits, *ptr; unsigned count, max; int fd; if (vt_set_mode(1)) return -1; fd = open(fn, O_RDONLY); if (fd < 0) { ERROR("cannot open '%s'\n", fn); goto fail_restore_text; } if (fstat(fd, &s) < 0) { goto fail_close_file; } data = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0); if (data == MAP_FAILED) goto fail_close_file; if (fb_open(&fb)) goto fail_unmap_data; max = fb_width(&fb) * fb_height(&fb); ptr = data; count = s.st_size; bits = fb.bits; while (count > 3) { unsigned n = ptr[0]; if (n > max) break; android_memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } munmap(data, s.st_size); fb_update(&fb); fb_close(&fb); close(fd); unlink(fn); return 0;fail_unmap_data: munmap(data, s.st_size); fail_close_file: close(fd);fail_restore_text: vt_set_mode(0); return -1;}调用：
static int vt_set_mode(int graphics){ int fd, r; fd = open("/dev/tty0", O_RDWR | O_SYNC); if (fd < 0) return -1; r = ioctl(fd, KDSETMODE, (void*) (graphics ? KD_GRAPHICS : KD_TEXT)); close(fd); return r;}打开控制控制台设备文件/dev/tty0，设置控制台的显示方式，传入参数为1，控制台将以图形方式显示。
往下就是打开传入的动画内容文件，fstat计算大小，通过mmap将initlogo.rle内容映射到init进程地址空间，
再打开/dev/graphics/fb0，通过打开这个设备文件就可以访问帧缓冲区设备，获取帧缓冲区设备的固定信息和可变信息，然后映射到init进程地址空间，
获取屏幕的宽高，计算出帧缓冲区能写入的大小，就知道在init进程地址空间上的大小，通过一个while循环将initlogo.rle内容写入到帧缓冲区设备上去。
更新init进程开机画面到屏幕上面：
static void fb_update(struct FB *fb){ fb->vi.yoffset = 1; ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi); fb->vi.yoffset = 0; ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi);}通过帧缓冲区设备渲染。三.系统服务启动动画：
这个动画是android系统最常用的一个动画，由bootainimation来负责显示运行，这在init.rc里面是作为一个service：
1.init.rc 配置：
service bootanim /system/bin/bootanimation class main user graphics group graphics disabled oneshot
这个是disabled，init启动解析的时候是不会被启动的。
2.SurfaceFinger服务的启动：
在前文http://blog.csdn.net/jscese/article/details/17115395#t7 中启动到system server部分启动了系统所需的一些服务时，在system_init.cpp中启动视频服务时会启动一个SurfaceFlinger的服务，获取一个SurfaceFinger的实例。
SurfaceFlinger类继承于BinderService模板类，BinderService类的instantiate()函数就是构造对应类型的服务对象，并注册到ServiceManager进程中/frameworks/native/include/binder/BinderService.h：
static void instantiate() { publish(); } static status_t publish(bool allowIsolated = false) { sp<IServiceManager> sm(defaultServiceManager()); return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated); }调用到/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp中构造：
SurfaceFlinger::SurfaceFlinger() : BnSurfaceComposer(), Thread(false), mTransactionFlags(0), mTransactionPending(false), mAnimTransactionPending(false), mLayersRemoved(false), mRepaintEverything(0), mBootTime(systemTime()), mVisibleRegionsDirty(false), mHwWorkListDirty(false), mDebugRegion(0), mDebugDDMS(0), mDebugDisableHWC(0), mDebugDisableTransformHint(0), mDebugInSwapBuffers(0), mLastSwapBufferTime(0), mDebugInTransaction(0), mLastTransactionTime(0), mBootFinished(false){ ALOGI("SurfaceFlinger is starting"); // debugging stuff... char value[PROPERTY_VALUE_MAX]; property_get("debug.sf.showupdates", value, "0"); mDebugRegion = atoi(value); property_get("debug.sf.ddms", value, "0"); mDebugDDMS = atoi(value); if (mDebugDDMS) { if (!startDdmConnection()) { // start failed, and DDMS debugging not enabled mDebugDDMS = 0; } } ALOGI_IF(mDebugRegion, "showupdates enabled"); ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");}这里的构造只是做了一些初始化，获取系统开机属性，设置一些变量。
因为SurfaceFlinger又继承于RefBase类，并重写了该类的onFirstRef()函数，我们知道，RefBase类的子类对象在第一次创建时，会自动调用onFirstRef()函数，因此在SurfaceFlinger对象构造完成时，将调用onFirstRef()函数。
void SurfaceFlinger::onFirstRef(){ mEventQueue.init(this); run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY); // Wait for the main thread to be done with its initialization mReadyToRunBarrier.wait();}这里就从SurfaceFlinger的父类Thread创建一个新的线程，加入threadLoop函数，调用到readyToRun()函数：
status_t SurfaceFlinger::readyToRun(){ ALOGI( "SurfaceFlinger's main thread ready to run. " "Initializing graphics H/W..."); ... // initialize OpenGL ES DisplayDevice::makeCurrent(mEGLDisplay, hw, mEGLContext); initializeGL(mEGLDisplay); // start the EventThread mEventThread = new EventThread(this); mEventQueue.setEventThread(mEventThread);... // start boot animation startBootAnim(); return NO_ERROR;}3.SurfaceFinger中开启bootainimation服务：
开始执行bootainimation。void SurfaceFlinger::startBootAnim() { // start boot animation property_set("service.bootanim.exit", "0"); property_set("ctl.start", "bootanim");}设置系统属性ctl.start 的值为bootanim。android的系统属性启动以及应用可以参考http://blog.csdn.net/jscese/article/details/18700903。
到这里就启动了一个新的服务进程bootanim，/frameworks/base/cmds/bootanimation/bootanimation_main.cpp
int main(int argc, char** argv){#if defined(HAVE_PTHREADS) setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);#endif char value[PROPERTY_VALUE_MAX]; property_get("debug.sf.nobootanimation", value, "0"); int noBootAnimation = atoi(value); ALOGI_IF(noBootAnimation, "boot animation disabled"); if (!noBootAnimation) { ALOGD("boot animation start"); sp<ProcessState> proc(ProcessState::self()); ProcessState::self()->startThreadPool(); // create the boot animation object sp<BootAnimation> boot = new BootAnimation(); IPCThreadState::self()->joinThreadPool(); } return 0;}获取nobootanimation这个属性的值，判断如果为0的话
那么接下来就会启动一个Binder线程池，并且创建一个BootAnimation对象。这个BootAnimation对象就是用来显示第三个开机画面的。由于BootAnimation对象在显示第三个开机画面的过程中，需要与SurfaceFlinger服务通信，因此，应用程序BootAnimation就需要启动一个Binder线程池。
BootAnimation类间接地继承了RefBase类，并且重写了RefBase类的成员函数onFirstRef，
BootAnimation类间接地继承了RefBase类，并且重写了RefBase类的成员函数onFirstRef，
因此，当一个BootAnimation对象第一次被智能指针引用的时，这个BootAnimation对象的成员函数onFirstRef就会被调用/frameworks/base/cmds/bootanimation/BootAnimation.cpp：
void BootAnimation::onFirstRef() { status_t err = mSession->linkToComposerDeath(this); ALOGE_IF(err, "linkToComposerDeath failed (%s) ", strerror(-err)); if (err == NO_ERROR) { run("BootAnimation", PRIORITY_DISPLAY); }}同时构造：
BootAnimation::BootAnimation() : Thread(false){ mSession = new SurfaceComposerClient();}mSession是BootAnimation类的一个成员变量，它的类型为SurfaceComposerClient，是用来和SurfaceFlinger执行Binder进程间通信的。
4.bootanimation线程构建：
BootAnimation类继承了Thread类，因此，当BootAnimation类的成员函数onFirstRef调用了父类Thread的成员函数run之后，系统就会创建一个线程，这个线程在第一次运行之前，会调用BootAnimation类的成员函数readyToRun来执行一些初始化工作，后面再调用BootAnimation类的成员函数threadLoop来显示第三个开机画面：
status_t BootAnimation::readyToRun() { mAssets.addDefaultAssets(); ... mAndroidAnimation = true; // If the device has encryption turned on or is in process // of being encrypted we show the encrypted boot animation. char decrypt[PROPERTY_VALUE_MAX]; property_get("vold.decrypt", decrypt, ""); bool encryptedAnimation = atoi(decrypt) != 0 || !strcmp("trigger_restart_min_framework", decrypt); if ((encryptedAnimation && (access(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE, R_OK) == 0) && (mZip.open(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE) == NO_ERROR)) || ((access(USER_BOOTANIMATION_FILE, R_OK) == 0) && (mZip.open(USER_BOOTANIMATION_FILE) == NO_ERROR)) || ((access(SYSTEM_BOOTANIMATION_FILE, R_OK) == 0) && (mZip.open(SYSTEM_BOOTANIMATION_FILE) == NO_ERROR))) { mAndroidAnimation = false; } return NO_ERROR;}在这里为绘制做准备，包括访问到帧缓冲区设备，获取屏幕显示大小等。
判断是否为android默认开机动画。
#define USER_BOOTANIMATION_FILE "/data/local/bootanimation.zip"#define SYSTEM_BOOTANIMATION_FILE "/system/media/bootanimation.zip"#define SYSTEM_ENCRYPTED_BOOTANIMATION_FILE "/system/media/bootanimation-encrypted.zip"
上面的文件只要有一个存在就代表不是android默认的 而是用户自定义的开机动画。
5.bootanimation执行动画：
准备工作做完了 就执行：
bool BootAnimation::threadLoop(){ bool r; if (mAndroidAnimation) { r = android(); } else { r = movie(); } eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroyContext(mDisplay, mContext); eglDestroySurface(mDisplay, mSurface); mFlingerSurface.clear(); mFlingerSurfaceControl.clear(); eglTerminate(mDisplay); IPCThreadState::self()->stopProcess(); return r;}1.android默认动画：
如果是android默认的开机动画：bool BootAnimation::android(){ initTexture(&mAndroid[0], mAssets, "images/android-logo-mask.png"); initTexture(&mAndroid[1], mAssets, "images/android-logo-shine.png"); // clear screen glShadeModel(GL_FLAT); glDisable(GL_DITHER); glDisable(GL_SCISSOR_TEST);...}这两张图片保存在frameworks/base/core/res/assets/images目录中.
图片android-logo-mask.png用作动画前景，它是一个镂空的“ANDROID”图像。图片android-logo-shine.png用作动画背景，它的中间包含有一个高亮的呈45度角的条纹。在每一次循环中，图片android-logo-shine.png被划分成左右两部分内容来显示。左右两个部分的图像宽度随着时间的推移而此消彼长，这样就可以使得图片android-logo-shine.png中间高亮的条纹好像在移动一样。另一方面，在每一次循环中，图片android-logo-shine.png都作为一个整体来渲染，而且它的位置是恒定不变的。由于它是一个镂空的“ANDROID”图像，因此，我们就可以通过它的镂空来看到它背后的图片android-logo-shine.png的条纹一闪一闪地划过。
2.用户自定义动画：
如果为用户自定义的开机动画：
bool BootAnimation::movie(){ZipFileRO& zip(mZip);size_t numEntries = zip.getNumEntries();ZipEntryRO desc = zip.findEntryByName("desc.txt");FileMap* descMap = zip.createEntryFileMap(desc);ALOGE_IF(!descMap, "descMap is null");if (!descMap) {return false;}String8 desString((char const*)descMap->getDataPtr(),descMap->getDataLength());char const* s = desString.string();Animation animation;// Parse the description filefor (;;) {const char* endl = strstr(s, "\n");if (!endl) break;String8 line(s, endl - s);const char* l = line.string();int fps, width, height, count, pause;char path[256];char pathType;if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {// ALOGD("> w=%d, h=%d, fps=%d", width, height, fps);// ALOGD("jscese> w=%d, h=%d", mWidth, mHeight);animation.width =width;animation.height =height;animation.fps = fps;}else if (sscanf(l, " %c %d %d %s", &pathType, &count, &pause, path) == 4) {//LOGD("> type=%c, count=%d, pause=%d, path=%s", pathType, count, pause, path);Animation::Part part;part.playUntilComplete = pathType == 'c';part.count = count;part.pause = pause;part.path = path;animation.parts.add(part);}s = ++endl;}...}找到解析bootanimation.zip 压缩包，找到desc.txt 文件，这个文件描述了显示的相关的特性，包括分辨率以及显示的帧率：
1920 1080 24 p 1 0 part1 p 0 10 part2
第一行的三个数字分别表示开机动画在屏幕中的显示宽度、高度以及帧速（fps）。剩余的每一行都用来描述一个动画片断，这些行必须要以字符“p”来开头，后面紧跟着两个数字以及一个文件目录路径名称。第一个数字表示一个片断的循环显示次数，如果它的值等于0，那么就表示无限循环地显示该动画片断。第二个数字表示每一个片断在两次循环显示之间的时间间隔。这个时间间隔是以一个帧的时间为单位的。文件目录下面保存的是一系列png文件，这些png文件会被依次显示在屏幕中。
以上面这个desct.txt文件的内容为例，它描述了一个大小为1920 x 1080的开机动画，动画的显示速度为24帧每秒。这个开机动画包含有两个片断part1和part2。片断part1只显示一次，它对应的png图片保存在目录part1中。片断part2无限循环地显示，其中，每两次循环显示的时间间隔为10 x (1 / 24)秒，它对应的png图片保存在目录part2中。
往后就是收集信息，通过帧缓冲区设备有次序的渲染这些图片了。
6.bootanimation停止：
1.activity的空闲通知：
当android开机启动到了Launcher，第一个被启动起来的应用程序的主线程空闲的时候，这个activity就会向ActivityManagerService发送一个Activity组件空闲的通知，
每当有一个新的Activity组件启动起来的时候，ActivityThread类都会向它所描述的应用程序主线程的消息队列注册一个类型为Idler的空闲消息处理器。这样一个应用程序的主线程就可以在空闲的时候，向ActivityManagerService发送一个Activity组件空闲通知，相当于是通知ActivityManagerService，一个新的Activity组件已经准备就绪了。
通过一系列的调用到/frameworks/base/services/java/com/android/server/am/ActivityManagerService.java中的：
public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) { final long origId = Binder.clearCallingIdentity(); ActivityRecord r = mMainStack.activityIdleInternal(token, false, config);...}final ActivityRecord activityIdleInternal(IBinder token, boolean fromTimeout,Configuration config) {if (localLOGV) Slog.v(TAG, "Activity idle: " + token);ActivityRecord res = null;...if (mMainStack) {if (!mService.mBooted) {mService.mBooted = true;enableScreen = true;}}...if (enableScreen) {mService.enableScreenAfterBoot();}...}回到ActivityManagerService.java中：
void enableScreenAfterBoot() { EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN, SystemClock.uptimeMillis()); mWindowManager.enableScreenAfterBoot(); synchronized (this) { updateEventDispatchingLocked(); } }2.WindowManagerService通信SurfaceFinger设置property：
调用到了WindowManagerService.java中的：
public void performEnableScreen() {synchronized(mWindowMap) {if (DEBUG_BOOT) {RuntimeException here = new RuntimeException("here");here.fillInStackTrace();...try { IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger"); if (surfaceFlinger != null) { //Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!"); Parcel data = Parcel.obtain(); data.writeInterfaceToken("android.ui.ISurfaceComposer"); surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, // BOOT_FINISHED data, null, 0); data.recycle(); }...}通过一个类型为IBinder.FIRST_CALL_TRANSACTION的进程间通信请求来通知SurfaceFlinger服务停止显示开机动画的.
void SurfaceFlinger::bootFinished(){ const nsecs_t now = systemTime();... property_set("service.bootanim.exit", "1");}最后还是通过设置android的系统属性通知到init守护进程，init进程来处理property的改变，在这里就是停掉bootanimation这个服务进程，bootanimation动画就停止掉了。