Android——开机动画

          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 = 3
PATCHLEVEL = 1
SUBLEVEL = 10
EXTRAVERSION =
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对象第一次被智能指针引用的时，这个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 file
for (;;) {
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中。

往后就是收集信息，通过帧缓冲区设备有次序的渲染这些图片了。

特别注意，android开机动画的zip包是不能压缩的！ 在ubuntu下可以使用一下命令制作bootanimation.zip：

zip -r -0 bootanimation.zip bootanimation/ desc.txt

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);
...
}

调用到/frameworks/base/services/java/com/android/server/am/ActivityStack.java中的：

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动画就停止掉了。