Android 7.1.2(Android N) BootaAi

Android 7.1.2(Android N) BootaAimation–开机动画显示流程

@(izhoujinjian)
高清原文

Android系统底层基于Linux Kernel, 当Kernel启动过程会创建init进程, 该进程是uoyou用户空间的鼻祖, init进程会启动servicemanager(binder服务管家), Zygote进程(Java进程的鼻祖). Zygote进程会创建 system_server进程以及各种app进程。init是Linux系统中用户空间的第一个进程(pid=1), Kerner启动后会调用/system/core/init/Init.cpp的main()方法，会解析surfaceflinger.rc中的服务。开机动画是在什么时候启动的呢？通过查看源码，android开机动画是在启动SurfaceFlinger服务时启动的。
Android N的.rc文件跟之前的版本有一些改变，具体可参考：Android 7.0 init.rc的一点改变

/frameworks/native/services/surfaceflinger/surfaceflinger.rc

service surfaceflinger /system/bin/surfaceflinger
class core
user system
group graphics drmrpc
onrestart restart zygote
writepid /dev/cpuset/system-background/tasks

surfaceflinger服务属于核心类(core class)，另外，当surfaceflinger重启时会触发zygote的重启。从surfaceflinger的 Android.mk文件可知，surfaceflinger服务启动的起点便是如下main_surfaceflinger的main()函数。

/frameworks/native/services/surfaceflinger/Android.mk

LOCAL_INIT_RC := surfaceflinger.rc
......
LOCAL_SRC_FILES := \
   main_surfaceflinger.cpp
......
LOCAL_MODULE := surfaceflinger

/frameworks/native/services/surfaceflinger/main_surfaceflinger.cpp

int main(int, char**) {
signal(SIGPIPE, SIG_IGN);
// When SF is launched in its own process, limit the number of
// binder threads to 4.
ProcessState::self()->setThreadPoolMaxThreadCount(4);

// start the thread pool
sp<ProcessState> ps(ProcessState::self());
ps->startThreadPool();

// instantiate surfaceflinger 实例化surfaceflinger
sp<SurfaceFlinger> flinger = new SurfaceFlinger();

setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);

set_sched_policy(0, SP_FOREGROUND);
#ifdef ENABLE_CPUSETS
// Put most SurfaceFlinger threads in the system-background cpuset
// Keeps us from unnecessarily using big cores
// Do this after the binder thread pool init
set_cpuset_policy(0, SP_SYSTEM);
#endif

// initialize before clients can connect 初始化
flinger->init();

// publish surface flinger 发布surface flinger，注册到Service Manager
sp<IServiceManager> sm(defaultServiceManager());
sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);

// publish GpuService
sp<GpuService> gpuservice = new GpuService();
sm->addService(String16(GpuService::SERVICE_NAME), gpuservice, false);

struct sched_param param = {0};
param.sched_priority = 2;
if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
    ALOGE("Couldn't set SCHED_FIFO");
}

// run surface flinger in this thread 运行在当前线程
flinger->run();

return 0;
}

该方法的主要功能：

设定surfaceflinger进程的binder线程池个数上限为4，并启动binder线程池；
创建SurfaceFlinger对；
设置surfaceflinger进程为高优先级以及前台调度策略；
初始化SurfaceFlinger；
将”SurfaceFlinger”服务注册到Service Manager;
在当前主线程执行SurfaceFlinger的run方法；

实例化surfaceflinger，sp<SurfaceFlinger> flinger = new SurfaceFlinger();

/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

SurfaceFlinger::SurfaceFlinger()
:   BnSurfaceComposer(),
    mTransactionFlags(0),
    mTransactionPending(false),
    mAnimTransactionPending(false),
    mLayersRemoved(false),
    mRepaintEverything(0),
    mRenderEngine(NULL),
    mBootTime(systemTime()),
    mBuiltinDisplays(),
    mVisibleRegionsDirty(false),
    mGeometryInvalid(false),
    mAnimCompositionPending(false),
    mDebugRegion(0),
    mDebugDDMS(0),
    mDebugDisableHWC(0),
    mDebugDisableTransformHint(0),
    mDebugInSwapBuffers(0),
    mLastSwapBufferTime(0),
    mDebugInTransaction(0),
    mLastTransactionTime(0),
    mBootFinished(false),
    mForceFullDamage(false),
    mPrimaryDispSync("PrimaryDispSync"),
    mPrimaryHWVsyncEnabled(false),
    mHWVsyncAvailable(false),
    mHasColorMatrix(false),
    mHasPoweredOff(false),
    mFrameBuckets(),
    mTotalTime(0),
    mLastSwapTime(0)
    {
ALOGI("SurfaceFlinger is starting");
// debugging stuff...
char value[PROPERTY_VALUE_MAX];

property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
mGpuToCpuSupported = !atoi(value);

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");

property_get("debug.sf.disable_backpressure", value, "0");
mPropagateBackpressure = !atoi(value);
ALOGI_IF(!mPropagateBackpressure, "Disabling backpressure propagation");

property_get("debug.sf.disable_hwc_vds", value, "0");
mUseHwcVirtualDisplays = !atoi(value);
ALOGI_IF(!mUseHwcVirtualDisplays, "Disabling HWC virtual displays");
}

SurfaceFlinger继承于BnSurfaceComposer: public BnInterface<ISurfaceComposer> ，class BnInterface : public INTERFACE, public BBinder，class BBinder : public IBinder，class IBinder : public virtual RefBase。
由于SurfaceFlinger继承于RefBase类，并重写了该类的onFirstRef()函数，我们知道，RefBase类的子类对象在第一次创建时，会自动调用onFirstRef()函数，因此在SurfaceFlinger对象构造完成时，将调用onFirstRef()函数。

<---SurfaceFlinger.cpp--->
void SurfaceFlinger::onFirstRef()
{
mEventQueue.init(this);
}

这里不对SurfaceFlinger的相关内容做详细介绍，本文的主要内容是介绍开机动画显示过程。

直接看SurfaceFlinger初始化 flinger->init();

<---SurfaceFlinger.cpp--->
void SurfaceFlinger::init() {
ALOGI(  "SurfaceFlinger's main thread ready to run. "
        "Initializing graphics H/W...");

{ // Autolock scope
    Mutex::Autolock _l(mStateLock);

    // initialize EGL for the default display
    mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    eglInitialize(mEGLDisplay, NULL, NULL);

    // start the EventThread
    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            vsyncPhaseOffsetNs, true, "app");
    mEventThread = new EventThread(vsyncSrc, *this);
    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
            sfVsyncPhaseOffsetNs, true, "sf");
    mSFEventThread = new EventThread(sfVsyncSrc, *this);
    mEventQueue.setEventThread(mSFEventThread);

    // set SFEventThread to SCHED_FIFO to minimize jitter
    struct sched_param param = {0};
    param.sched_priority = 2;
    if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
        ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
    }

    // Get a RenderEngine for the given display / config (can't fail)
    mRenderEngine = RenderEngine::create(mEGLDisplay,
            HAL_PIXEL_FORMAT_RGBA_8888);
}

// Drop the state lock while we initialize the hardware composer. We drop
// the lock because on creation, it will call back into SurfaceFlinger to
// initialize the primary display.
mHwc = new HWComposer(this);
mHwc->setEventHandler(static_cast<HWComposer::EventHandler*>(this));

Mutex::Autolock _l(mStateLock);

// retrieve the EGL context that was selected/created
mEGLContext = mRenderEngine->getEGLContext();

LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
        "couldn't create EGLContext");

// make the GLContext current so that we can create textures when creating
// Layers (which may happens before we render something)
getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);

mEventControlThread = new EventControlThread(this);
mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);

// initialize our drawing state
mDrawingState = mCurrentState;

// set initial conditions (e.g. unblank default device)
initializeDisplays();

mRenderEngine->primeCache();

// start boot animation
startBootAnim();

ALOGV("Done initializing");
}

该函数首先是初始化Android的图形显示系统，启动SurfaceFlinger事件线程，这些内容只有了解了Android的显示原理及SurfaceFlinger服务之后才能理解，这里不做介绍。当显示系统初始化完毕后，调用startBootAnim()函数来显示开机动画。

<---SurfaceFlinger.cpp--->
void SurfaceFlinger::startBootAnim() {
// start boot animation
property_set("service.bootanim.exit", "0");
property_set("ctl.start", "bootanim");
}

启动开机动画进程也是通过Android属性系统来实现的，具体启动过程可以查看Android 系统属性SystemProperty实现方式。在Android系统启动脚本bootanim .rc中配置了开机动画服务进程。
/frameworks/base/cmds/bootanimation/bootanim.rc

service bootanim /system/bin/bootanimation
class core
user graphics
group graphics audio
disabled
oneshot
writepid /dev/stune/top-app/tasks

property_set("ctl.start", "bootanim");就是启动bootanim进程来显示开机动画，该进程对应的源码位于

/frameworks/base/cmds/bootanimation/bootanimation_main.cpp

int main(){
setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_DISPLAY);

char value[PROPERTY_VALUE_MAX];
property_get("debug.sf.nobootanimation", value, "0");
int noBootAnimation = atoi(value);
ALOGI_IF(noBootAnimation,  "boot animation disabled");
if (!noBootAnimation) {

    sp<ProcessState> proc(ProcessState::self());
    ProcessState::self()->startThreadPool();

    // create the boot animation object
    sp<BootAnimation> boot = new BootAnimation();

    IPCThreadState::self()->joinThreadPool();

}
return 0;
}

该函数构造了一个BootAnimation对象，同时创建了Binder线程池，并将bootanim进程的主线程注册到Binder线程池中，用于接收客户进程的Binder通信请求。

/frameworks/base/cmds/bootanimation/BootAnimation.cpp

BootAnimation::BootAnimation() : Thread(false), mClockEnabled(true), mTimeIsAccurate(false),
    mTimeFormat12Hour(false), mTimeCheckThread(NULL) {
mSession = new SurfaceComposerClient();

// If the system has already booted, the animation is not being used for a boot.
mSystemBoot = !property_get_bool(BOOT_COMPLETED_PROP_NAME, 0);
}

在构造BootAnimation对象时，实例化SurfaceComposerClient对象，用于请求SurfaceFlinger显示开关机动画。由于BootAnimation类继承于RefBase，同时重写了onFirstRef()函数，因此在构造BootAnimation对象时，会调用该函数。

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

该函数首先为SurfaceComposerClient对象注册Binder死亡通知,然后调用BootAnimation的run方法,由于BootAnimation同时继承于Thread类,前面介绍SurfaceFlinger时已经介绍到,当某个类继承于Thread类时,当调用该类的run函数时,函数首先会执行readyToRun()函数来完成线程执行前的一些工作,然后线程反复执行threadLoop()函数,在BootAnimation类中,同样重新了这两个方法。

static const char OEM_BOOTANIMATION_FILE[] = "/oem/media/bootanimation.zip";
static const char SYSTEM_BOOTANIMATION_FILE[] = "/system/media/bootanimation.zip";
static const char SYSTEM_ENCRYPTED_BOOTANIMATION_FILE[] = "/system/media/bootanimation-encrypted.zip";
status_t BootAnimation::readyToRun() {
mAssets.addDefaultAssets();

sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
        ISurfaceComposer::eDisplayIdMain));
DisplayInfo dinfo;
status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &dinfo);
if (status)
    return -1;

// create the native surface
sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"),
        dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);

SurfaceComposerClient::openGlobalTransaction();
control->setLayer(0x40000000);
SurfaceComposerClient::closeGlobalTransaction();

sp<Surface> s = control->getSurface();

// initialize opengl and egl
const EGLint attribs[] = {
        EGL_RED_SIZE,   8,
        EGL_GREEN_SIZE, 8,
        EGL_BLUE_SIZE,  8,
        EGL_DEPTH_SIZE, 0,
        EGL_NONE
};
EGLint w, h;
EGLint numConfigs;
EGLConfig config;
EGLSurface surface;
EGLContext context;

EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

eglInitialize(display, 0, 0);
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
surface = eglCreateWindowSurface(display, config, s.get(), NULL);
context = eglCreateContext(display, config, NULL, NULL);
eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);

if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
    return NO_INIT;

mDisplay = display;
mContext = context;
mSurface = surface;
mWidth = w;
mHeight = h;
mFlingerSurfaceControl = control;
mFlingerSurface = s;

// 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)) {
    mZipFileName = SYSTEM_ENCRYPTED_BOOTANIMATION_FILE;
}
else if (access(OEM_BOOTANIMATION_FILE, R_OK) == 0) {
    mZipFileName = OEM_BOOTANIMATION_FILE;
}
else if (access(SYSTEM_BOOTANIMATION_FILE, R_OK) == 0) {
    mZipFileName = SYSTEM_BOOTANIMATION_FILE;
}
return NO_ERROR;
}

在该函数里创建SurfaceControl对象,通过SurfaceControl对象得到Surface对象,并初始化好OpenGL，同时判断动画文件是否存在，如果不存在，则设置标志位mAndroidAnimation为true，表示显示Android滚动字样。当初始化完这些必需资源后，线程进入循环执行体threadLoop()。

bool BootAnimation::threadLoop()
{
bool r;
// We have no bootanimation file, so we use the stock android logo
// animation.如果mAndroidAnimation为true，表示动画文件不存在，则显示Android滚动字样  
if (mZipFileName.isEmpty()) {
    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;
}

开机画面主要是由一个zip格式的压缩包bootanimation.zip组成，压缩包里面包含数张png格式的图片，还有一个desc.txt的文本文档，开机时按desc.txt里面的指令，屏幕上会按文件名称顺序连续的播放一张张的图片，就像播放原始的胶带影片一样，形成动画。desc.txt是一个保存形式为ANSI格式的文件，用于设置这个动画像素（大小），帧数，闪烁次数，文件夹名称等。内容如下（bootanimation.zip基于Google pixel手机Android 7.1.2）：

1440 240 60
c 1 0 part0 #FFFFFF -1
c 0 0 part1 #FFFFFF -1
c 1 0 part2 #FFFFFF -1

1440 240 60 ---这里的1440 代表图片的像素（大小）宽度，240 代表图片的像素（大小）高度，60 代表帧数；

c 1 0 part0 ---这里的c代表标志符，1代表循环次数为1次，0代表阶段间隔时间为0，part0代表对应的文件夹名，为第一阶段动画图片目录；

c 0 0 part1---这里的c代表标志符，0代表本阶段无限循环，0代表阶段间隔时间为0，part1代表对应的文件夹名，为第二阶段动画图片目录；

c 1 0 part2---这里的c代表标志符，1代表本阶段无限循环，0代表阶段间隔时间为0，part2代表对应的文件夹名，为第三阶段动画图片目录；

bootanimation.gif

bootanimation.zip && bootanimation.gif

bool BootAnimation::movie()
{
//加载动画文件
Animation* animation = loadAnimation(mZipFileName);
if (animation == NULL)
    return false;

bool anyPartHasClock = false;
for (size_t i=0; i < animation->parts.size(); i++) {
    if(validClock(animation->parts[i])) {
        anyPartHasClock = true;
        break;
    }
}
if (!anyPartHasClock) {
    mClockEnabled = false;
}

// Check if npot textures are supported
mUseNpotTextures = false;
String8 gl_extensions;
const char* exts = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
if (!exts) {
    glGetError();
} else {
    gl_extensions.setTo(exts);
    if ((gl_extensions.find("GL_ARB_texture_non_power_of_two") != -1) ||
        (gl_extensions.find("GL_OES_texture_npot") != -1)) {
        mUseNpotTextures = true;
    }
}

// Blend required to draw time on top of animation frames.
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_FLAT);
glDisable(GL_DITHER);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);

glBindTexture(GL_TEXTURE_2D, 0);
glEnable(GL_TEXTURE_2D);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

bool clockFontInitialized = false;
if (mClockEnabled) {
    clockFontInitialized =
        (initFont(&animation->clockFont, CLOCK_FONT_ASSET) == NO_ERROR);
    mClockEnabled = clockFontInitialized;
}

if (mClockEnabled && !updateIsTimeAccurate()) {
    mTimeCheckThread = new TimeCheckThread(this);
    mTimeCheckThread->run("BootAnimation::TimeCheckThread", PRIORITY_NORMAL);
}
//播放动画
playAnimation(*animation);

if (mTimeCheckThread != NULL) {
    mTimeCheckThread->requestExit();
    mTimeCheckThread = NULL;
}

releaseAnimation(animation);

if (clockFontInitialized) {
    glDeleteTextures(1, &animation->clockFont.texture.name);
}

return false;
}

进入loadAnimation()函数。

BootAnimation::Animation* BootAnimation::loadAnimation(const String8& fn)
{
if (mLoadedFiles.indexOf(fn) >= 0) {
    ALOGE("File \"%s\" is already loaded. Cyclic ref is not allowed",
        fn.string());
    return NULL;
}
ZipFileRO *zip = ZipFileRO::open(fn);
if (zip == NULL) {
    ALOGE("Failed to open animation zip \"%s\": %s",
        fn.string(), strerror(errno));
    return NULL;
}

Animation *animation =  new Animation;
animation->fileName = fn;
animation->zip = zip;
animation->clockFont.map = nullptr;
mLoadedFiles.add(animation->fileName);

parseAnimationDesc(*animation);
if (!preloadZip(*animation)) {
    return NULL;
}


mLoadedFiles.remove(fn);
return animation;
}




bool BootAnimation::parseAnimationDesc(Animation& animation)
{
String8 desString;
//打开zip压缩文件中的desc.txt文件
if (!readFile(animation.zip, "desc.txt", desString)) {
    return false;
}
char const* s = desString.string();
//解析desc.txt文件内容  
// Parse the description file
for (;;) {//从字符串s中查找是否有字符串"\n"，如果有，返回s中"\n"起始位置的指针，如果没有，返回null。  
    const char* endl = strstr(s, "\n");
    if (endl == NULL) break;
    String8 line(s, endl - s);
    //取得文件一行内容
    const char* l = line.string();
    int fps = 0;
    int width = 0;
    int height = 0;
    int count = 0;
    int pause = 0;
    char path[ANIM_ENTRY_NAME_MAX];
    char color[7] = "000000"; // default to black if unspecified
    char clockPos1[TEXT_POS_LEN_MAX + 1] = "";
    char clockPos2[TEXT_POS_LEN_MAX + 1] = "";

    char pathType;
    //从文件第一行中读取宽度，高度，帧数  
    if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {
        // ALOGD("> w=%d, h=%d, fps=%d", width, height, fps);
        animation.width = width;
        animation.height = height;
        animation.fps = fps;
    } else if (sscanf(l, " %c %d %d %s #%6s %16s %16s",
                      &pathType, &count, &pause, path, color, clockPos1, clockPos2) >= 4) {
        //ALOGD("> type=%c, count=%d, pause=%d, path=%s, color=%s, clockPos1=%s, clockPos2=%s",
        //    pathType, count, pause, path, color, clockPos1, clockPos2);
        //    一个part描述一个动画文件夹内容  
        Animation::Part part;
        part.playUntilComplete = pathType == 'c';
        part.count = count;
        part.pause = pause;
        part.path = path;
        part.audioData = NULL;
        part.animation = NULL;
        if (!parseColor(color, part.backgroundColor)) {
            ALOGE("> invalid color '#%s'", color);
            part.backgroundColor[0] = 0.0f;
            part.backgroundColor[1] = 0.0f;
            part.backgroundColor[2] = 0.0f;
        }
        parsePosition(clockPos1, clockPos2, &part.clockPosX, &part.clockPosY);
        animation.parts.add(part);
    }
    else if (strcmp(l, "$SYSTEM") == 0) {
        // ALOGD("> SYSTEM");
        Animation::Part part;
        part.playUntilComplete = false;
        part.count = 1;
        part.pause = 0;
        part.audioData = NULL;
        part.animation = loadAnimation(String8(SYSTEM_BOOTANIMATION_FILE));
        if (part.animation != NULL)
            animation.parts.add(part);
    }
    s = ++endl;
}

return true;

}

进入playAnimation()、releaseAnimation()数。

 bool BootAnimation::playAnimation(const Animation& animation)
{
//读取动画个数  
const size_t pcount = animation.parts.size();
nsecs_t frameDuration = s2ns(1) / animation.fps;
const int animationX = (mWidth - animation.width) / 2;
const int animationY = (mHeight - animation.height) / 2;
//遍历zip压缩包中的所有文件  
for (size_t i=0 ; i<pcount ; i++) {
    const Animation::Part& part(animation.parts[i]);
    const size_t fcount = part.frames.size();
    glBindTexture(GL_TEXTURE_2D, 0);

    // Handle animation package
    if (part.animation != NULL) {
        playAnimation(*part.animation);
        if (exitPending())
            break;
        continue; //to next part
    }
    //循环显示文件夹下的图片  
    for (int r=0 ; !part.count || r<part.count ; r++) {
        // Exit any non playuntil complete parts immediately
        if(exitPending() && !part.playUntilComplete)
            break;

        // only play audio file the first time we animate the part
        if (r == 0 && part.audioData && playSoundsAllowed()) {
            ALOGD("playing clip for part%d, size=%d", (int) i, part.audioLength);
            audioplay::playClip(part.audioData, part.audioLength);
        }

        glClearColor(
                part.backgroundColor[0],
                part.backgroundColor[1],
                part.backgroundColor[2],
                1.0f);

        for (size_t j=0 ; j<fcount && (!exitPending() || part.playUntilComplete) ; j++) {
            const Animation::Frame& frame(part.frames[j]);
            nsecs_t lastFrame = systemTime();

            if (r > 0) {
                glBindTexture(GL_TEXTURE_2D, frame.tid);
            } else {
                if (part.count != 1) {
                    glGenTextures(1, &frame.tid);
                    glBindTexture(GL_TEXTURE_2D, frame.tid);
                    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                }
                int w, h;
                initTexture(frame.map, &w, &h);
            }

            const int xc = animationX + frame.trimX;
            const int yc = animationY + frame.trimY;
            Region clearReg(Rect(mWidth, mHeight));
            clearReg.subtractSelf(Rect(xc, yc, xc+frame.trimWidth, yc+frame.trimHeight));
            if (!clearReg.isEmpty()) {
                Region::const_iterator head(clearReg.begin());
                Region::const_iterator tail(clearReg.end());
                glEnable(GL_SCISSOR_TEST);
                while (head != tail) {
                    const Rect& r2(*head++);
                    glScissor(r2.left, mHeight - r2.bottom, r2.width(), r2.height());
                    glClear(GL_COLOR_BUFFER_BIT);
                }
                glDisable(GL_SCISSOR_TEST);
            }
            // specify the y center as ceiling((mHeight - frame.trimHeight) / 2)
            // which is equivalent to mHeight - (yc + frame.trimHeight)
            glDrawTexiOES(xc, mHeight - (yc + frame.trimHeight),
                          0, frame.trimWidth, frame.trimHeight);
            if (mClockEnabled && mTimeIsAccurate && validClock(part)) {
                drawClock(animation.clockFont, part.clockPosX, part.clockPosY);
            }

            eglSwapBuffers(mDisplay, mSurface);

            nsecs_t now = systemTime();
            nsecs_t delay = frameDuration - (now - lastFrame);
            //ALOGD("%lld, %lld", ns2ms(now - lastFrame), ns2ms(delay));
            lastFrame = now;

            if (delay > 0) {
                struct timespec spec;
                spec.tv_sec  = (now + delay) / 1000000000;
                spec.tv_nsec = (now + delay) % 1000000000;
                int err;
                do {
                    err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
                } while (err<0 && errno == EINTR);
            }

            checkExit();
        }

        usleep(part.pause * ns2us(frameDuration));

        // For infinite parts, we've now played them at least once, so perhaps exit
        if(exitPending() && !part.count)
            break;
    }

}

// Free textures created for looping parts now that the animation is done.
for (const Animation::Part& part : animation.parts) {
    if (part.count != 1) {
        const size_t fcount = part.frames.size();
        for (size_t j = 0; j < fcount; j++) {
            const Animation::Frame& frame(part.frames[j]);
            glDeleteTextures(1, &frame.tid);
        }
    }
}

// we've finally played everything we're going to play
audioplay::setPlaying(false);
audioplay::destroy();

return true;
}


void BootAnimation::releaseAnimation(Animation* animation) const
{
for (Vector<Animation::Part>::iterator it = animation->parts.begin(),
     e = animation->parts.end(); it != e; ++it) {
    if (it->animation)
        releaseAnimation(it->animation);
}
if (animation->zip)
    delete animation->zip;
delete animation;
}

参考文档：

Android 7.0 init.rc的一点改变
Android 开机动画显示源码分析