Android系统的开机画面显示过程分析

http://shyluo.blog.51cto.com/5725845/967046

BootAnimation类的成员函数movie的实现比较长，我们分段来阅读：

 
 

   
   

    
    bool BootAnimation::movie()   
   
   

   
   

    
    {   
   
   

   
   

    
        ZipFileRO& zip(mZip);   
   
   

   
   

    
       
   
   

   
   

    
        size_t numEntries = zip.getNumEntries();   
   
   

   
   

    
        ZipEntryRO desc = zip.findEntryByName("desc.txt");   
   
   

   
   

    
        FileMap* descMap = zip.createEntryFileMap(desc);   
   
   

   
   

    
        LOGE_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];   
   
   

   
   

    
            if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {   
   
   

   
   

    
                //LOGD("> w=%d, h=%d, fps=%d", fps, width, height);   
   
   

   
   

    
                animation.width = width;   
   
   

   
   

    
                animation.height = height;   
   
   

   
   

    
                animation.fps = fps;   
   
   

   
   

    
            }   
   
   

   
   

    
            if (sscanf(l, "p %d %d %s", &count, &pause, path) == 3) {   
   
   

   
   

    
                //LOGD("> count=%d, pause=%d, path=%s", count, pause, path);   
   
   

   
   

    
                Animation::Part part;   
   
   

   
   

    
                part.count = count;   
   
   

   
   

    
                part.pause = pause;   
   
   

   
   

    
                part.path = path;   
   
   

   
   

    
                animation.parts.add(part);   
   
   

   
   

    
            }   
   
   

   
   

    
            s = ++endl;   
   
   

   
   

    
        }   
   
   

     从前面BootAnimation类的成员函数readyToRun的实现可以知道，如果目标设备上存在压缩文件/data/local/bootanimation.zip，那么BootAnimation类的成员变量mZip就会指向它，否则的话，就会指向目标设备上的压缩文件/system/media/bootanimation.zip。无论BootAnimation类的成员变量mZip指向的是哪一个压缩文件，这个压缩文件都必须包含有一个名称为“desc.txt”的文件，用来描述用户自定义的开机动画是如何显示的。

 

文件desc.txt的内容格式如下面的例子所示：

 
 

   
   

    
    600 480 24   
   
   

   
   

    
    p   1   0   part1   
   
   

   
   

    
    p   0   10  part2   
   
   

        第一行的三个数字分别表示开机动画在屏幕中的显示宽度、高度以及帧速（fps）。剩余的每一行都用来描述一个动画片断，这些行必须要以字符“p”来开头，后面紧跟着两个数字以及一个文件目录路径名称。第一个数字表示一个片断的循环显示次数，如果它的值等于0，那么就表示无限循环地显示该动画片断。第二个数字表示每一个片断在两次循环显示之间的时间间隔。这个时间间隔是以一个帧的时间为单位的。文件目录下面保存的是一系列png文件，这些png文件会被依次显示在屏幕中。

 

       以上面这个desct.txt文件的内容为例，它描述了一个大小为600 x 480的开机动画，动画的显示速度为24帧每秒。这个开机动画包含有两个片断part1和part2。片断part1只显示一次，它对应的png图片保存在目录part1中。片断part2无限循环地显示，其中，每两次循环显示的时间间隔为10 x (1 / 24)秒，它对应的png图片保存在目录part2中。

       上面的for循环语句分析完成desc.txt文件的内容后，就得到了开机动画的显示大小、速度以及片断信息。这些信息都保存在Animation对象animation中，其中，每一个动画片断都使用一个Animation::Part对象来描述，并且保存在Animation对象animation的成员变量parts所描述的一个片断列表中。

       接下来，BootAnimation类的成员函数movie再断续将每一个片断所对应的png图片读取出来，如下所示：

 
 

   
   

    
    // read all the data structures   
   
   

   
   

    
    const size_t pcount = animation.parts.size();   
   
   

   
   

    
    for (size_t i=0 ; i<numEntries ; i++) {   
   
   

   
   

    
        char name[256];   
   
   

   
   

    
        ZipEntryRO entry = zip.findEntryByIndex(i);   
   
   

   
   

    
        if (zip.getEntryFileName(entry, name, 256) == 0) {   
   
   

   
   

    
            const String8 entryName(name);   
   
   

   
   

    
            const String8 path(entryName.getPathDir());   
   
   

   
   

    
            const String8 leaf(entryName.getPathLeaf());   
   
   

   
   

    
            if (leaf.size() > 0) {   
   
   

   
   

    
                for (int j=0 ; j<pcount ; j++) {   
   
   

   
   

    
                    if (path == animation.parts[j].path) {   
   
   

   
   

    
                        int method;   
   
   

   
   

    
                        // supports only stored png files   
   
   

   
   

    
                        if (zip.getEntryInfo(entry, &method, 0, 0, 0, 0, 0)) {   
   
   

   
   

    
                            if (method == ZipFileRO::kCompressStored) {   
   
   

   
   

    
                                FileMap* map = zip.createEntryFileMap(entry);   
   
   

   
   

    
                                if (map) {   
   
   

   
   

    
                                    Animation::Frame frame;   
   
   

   
   

    
                                    frame.name = leaf;   
   
   

   
   

    
                                    frame.map = map;   
   
   

   
   

    
                                    Animation::Part& part(animation.parts.editItemAt(j));   
   
   

   
   

    
                                    part.frames.add(frame);   
   
   

   
   

    
                                }   
   
   

   
   

    
                            }   
   
   

   
   

    
                        }   
   
   

   
   

    
                    }   
   
   

   
   

    
                }   
   
   

   
   

    
            }   
   
   

   
   

    
        }   
   
   

   
   

    
    }   
   
   

      每一个png图片都表示一个动画帧，使用一个Animation::Frame对象来描述，并且保存在对应的Animation::Part对象的成员变量frames所描述的一个帧列表中。

 

        获得了开机动画的所有信息之后，接下来BootAnimation类的成员函数movie就准备开始显示开机动画了，如下所示：

 
 

   
   

    
    // clear screen   
   
   

   
   

    
    glShadeModel(GL_FLAT);   
   
   

   
   

    
    glDisable(GL_DITHER);   
   
   

   
   

    
    glDisable(GL_SCISSOR_TEST);   
   
   

   
   

    
    glDisable(GL_BLEND);   
   
   

   
   

    
    glClear(GL_COLOR_BUFFER_BIT);   
   
   

   
   

    
       
   
   

   
   

    
    eglSwapBuffers(mDisplay, mSurface);   
   
   

   
   

    
       
   
   

   
   

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

   
   

    
       
   
   

   
   

    
    const int xc = (mWidth - animation.width) / 2;   
   
   

   
   

    
    const int yc = ((mHeight - animation.height) / 2);   
   
   

   
   

    
    nsecs_t lastFrame = systemTime();   
   
   

   
   

    
    nsecs_t frameDuration = s2ns(1) / animation.fps;   
   
   

   
   

    
       
   
   

   
   

    
    Region clearReg(Rect(mWidth, mHeight));   
   
   

   
   

    
    clearReg.subtractSelf(Rect(xc, yc, xc+animation.width, yc+animation.height));   
   
   

       前面的一系列gl函数首先用来清理屏幕，接下来的一系列gl函数用来设置OpenGL的纹理显示方式。

 

       变量xc和yc的值用来描述开机动画的显示位置，即需要在屏幕中间显示开机动画，另外一个变量frameDuration的值用来描述每一帧的显示时间，它是以纳秒为单位的。

       Region对象clearReg用来描述屏幕中除了开机动画之外的其它区域，它是用整个屏幕区域减去开机动画所点据的区域来得到的。

       准备好开机动画的显示参数之后，最后就可以执行显示开机动画的操作了，如下所示：

 
 

   
   

    
        for (int i=0 ; i<pcount && !exitPending() ; i++) {   
   
   

   
   

    
            const Animation::Part& part(animation.parts[i]);   
   
   

   
   

    
            const size_t fcount = part.frames.size();   
   
   

   
   

    
            glBindTexture(GL_TEXTURE_2D, 0);   
   
   

   
   

    
       
   
   

   
   

    
            for (int r=0 ; !part.count || r<part.count ; r++) {   
   
   

   
   

    
                for (int j=0 ; j<fcount && !exitPending(); j++) {   
   
   

   
   

    
                    const Animation::Frame& frame(part.frames[j]);   
   
   

   
   

    
       
   
   

   
   

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

   
   

    
                        }   
   
   

   
   

    
                        initTexture(   
   
   

   
   

    
                                frame.map->getDataPtr(),   
   
   

   
   

    
                                frame.map->getDataLength());   
   
   

   
   

    
                    }   
   
   

   
   

    
       
   
   

   
   

    
                    if (!clearReg.isEmpty()) {   
   
   

   
   

    
                        Region::const_iterator head(clearReg.begin());   
   
   

   
   

    
                        Region::const_iterator tail(clearReg.end());   
   
   

   
   

    
                        glEnable(GL_SCISSOR_TEST);   
   
   

   
   

    
                        while (head != tail) {   
   
   

   
   

    
                            const Rect& r(*head++);   
   
   

   
   

    
                            glScissor(r.left, mHeight - r.bottom,   
   
   

   
   

    
                                    r.width(), r.height());   
   
   

   
   

    
                            glClear(GL_COLOR_BUFFER_BIT);   
   
   

   
   

    
                        }   
   
   

   
   

    
                        glDisable(GL_SCISSOR_TEST);   
   
   

   
   

    
                    }   
   
   

   
   

    
                    glDrawTexiOES(xc, yc, 0, animation.width, animation.height);   
   
   

   
   

    
                    eglSwapBuffers(mDisplay, mSurface);   
   
   

   
   

    
       
   
   

   
   

    
                    nsecs_t now = systemTime();   
   
   

   
   

    
                    nsecs_t delay = frameDuration - (now - lastFrame);   
   
   

   
   

    
                    lastFrame = now;   
   
   

   
   

    
                    long wait = ns2us(frameDuration);   
   
   

   
   

    
                    if (wait > 0)   
   
   

   
   

    
                        usleep(wait);   
   
   

   
   

    
                }   
   
   

   
   

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

   
   

    
            }   
   
   

   
   

    
       
   
   

   
   

    
            // free the textures for this part   
   
   

   
   

    
            if (part.count != 1) {   
   
   

   
   

    
                for (int j=0 ; j<fcount ; j++) {   
   
   

   
   

    
                    const Animation::Frame& frame(part.frames[j]);   
   
   

   
   

    
                    glDeleteTextures(1, &frame.tid);   
   
   

   
   

    
                }   
   
   

   
   

    
            }   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        return false;   
   
   

   
   

    
    }   
   
   

        第一层for循环用来显示每一个动画片断，第二层的for循环用来循环显示每一个动画片断，第三层的for循环用来显示每一个动画片断所对应的png图片。这些png图片以纹理的方式来显示在屏幕中。

 

        注意，如果一个动画片断的循环显示次数不等于1，那么就说明这个动画片断中的png图片需要重复地显示在屏幕中。由于每一个png图片都需要转换为一个纹理对象之后才能显示在屏幕中，因此，为了避免重复地为同一个png图片创建纹理对象，第三层的for循环在第一次显示一个png图片的时候，会调用函数glGenTextures来为这个png图片创建一个纹理对象，并且将这个纹理对象的名称保存在对应的Animation::Frame对象的成员变量tid中，这样，下次再显示相同的图片时，就可以使用前面已经创建好了的纹理对象，即调用函数glBindTexture来指定当前要操作的纹理对象。

        如果Region对象clearReg所包含的区域不为空，那么在调用函数glDrawTexiOES和eglSwapBuffers来显示每一个png图片之前，首先要将它所包含的区域裁剪掉，避免开机动画可以显示在指定的位置以及大小中。

        每当显示完成一个png图片之后，都要将变量frameDuration的值从纳秒转换为毫秒。如果转换后的值大小于，那么就需要调用函数usleep函数来让线程睡眠一下，以保证每一个png图片，即每一帧动画都按照预先指定好的速度来显示。注意，函数usleep指定的睡眠时间只能精确到毫秒，因此，如果预先指定的帧显示时间小于1毫秒，那么BootAnimation类的成员函数movie是无法精确地控制地每一帧的显示时间的。

        还有另外一个地方需要注意的是，每当循环显示完成一个片断时，需要调用usleep函数来使得线程睡眠part.pause * ns2us(frameDuration)毫秒，以便可以按照预先设定的节奏来显示开机动画。

        最后一个if语句判断一个动画片断是否是循环显示的，即循环次数不等于1。如果是的话，那么就说明前面为它所对应的每一个png图片都创建过一个纹理对象。现在既然这个片断的显示过程已经结束了，因此，就需要释放前面为它所创建的纹理对象。

        至此，第三个开机画面的显示过程就分析完成了。

 接下来，我们再继续分析第三个开机画面是如何停止显示的。

        从前面 Android系统默认Home应用程序（Launcher）的启动过程源代码分析 一文可以知道，当System进程将系统中的关键服务启动起来之后，就会将应用程序启动器（Launcher）启动起来。从 Android应用程序启动过程源代码分析 一文又可以知道，Android应用程序的启动过程实际上就是它的根Activity组件的启动过程。对于应用程序Launcher来说，它的根Activity组件即为Launcher组件。

        一个Activity组件在启动起来之后，就会被记录起来，等到它所运行在的主线程空闲的时候，这个主线程就会向ActivityManagerService发送一个Activity组件空闲的通知。由于应用程序Launcher是系统中第一个被启动的应用程序，即它的根Activity组件是系统中第一个被启动的Activity组件，因此，当ActivityManagerService接收到它的空闲通知的时候，就可以知道系统是刚刚启动起来的。在这种情况下，ActivityManagerService就会停止显示开机动画，以便可以在屏幕中显示应用程序Lancher的界面。

       从前面 Android应用程序消息处理机制（Looper、Handler）分析 一文可以知道，如果一个线程想要在空闲的时候处理一些事务，那么就必须要向这个线程的消息队列注册一个空闲消息处理器。自定义的空闲消息处理器灯必须要从MessageQueue.IdleHandler类继承下来，并且重写成员函数queueIdle。当一个线程空闲的时候，即消息队列中没有新的消息需要处理的时候，那些注册了的空闲消息处理器的成员函数queueIdle就会被调用。

       应用程序的主线程是通过ActivityThread类来描述的，它实现在文件frameworks/base/core/java/android/app/ActivityThread.java中。每当有一个新的Activity组件启动起来的时候，ActivityThread类都会向它所描述的应用程序主线程的消息队列注册一个类型为Idler的空闲消息处理器。这样一个应用程序的主线程就可以在空闲的时候，向ActivityManagerService发送一个Activity组件空闲通知，相当于是通知ActivityManagerService，一个新的Activity组件已经准备就绪了。

Idler类定义在frameworks/base/core/java/android/app/ActivityThread.java中， 它的成员函数queueIdle的实现如下所示： 

 
 

   
   

    
    public final class ActivityThread {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        private final class Idler implements MessageQueue.IdleHandler {   
   
   

   
   

    
            public final boolean queueIdle() {   
   
   

   
   

    
                ActivityClientRecord a = mNewActivities;   
   
   

   
   

    
                if (a != null) {   
   
   

   
   

    
                    mNewActivities = null;   
   
   

   
   

    
                    IActivityManager am = ActivityManagerNative.getDefault();   
   
   

   
   

    
                    ActivityClientRecord prev;   
   
   

   
   

    
                    do {   
   
   

   
   

    
                        ......   
   
   

   
   

    
                        if (a.activity != null && !a.activity.mFinished) {   
   
   

   
   

    
                            try {   
   
   

   
   

    
                                am.activityIdle(a.token, a.createdConfig);   
   
   

   
   

    
                                a.createdConfig = null;   
   
   

   
   

    
                            } catch (RemoteException ex) {   
   
   

   
   

    
                            }   
   
   

   
   

    
                        }   
   
   

   
   

    
                        prev = a;   
   
   

   
   

    
                        a = a.nextIdle;   
   
   

   
   

    
                        prev.nextIdle = null;   
   
   

   
   

    
                    } while (a != null);   
   
   

   
   

    
                }   
   
   

   
   

    
                ensureJitEnabled();   
   
   

   
   

    
                return false;   
   
   

   
   

    
            }   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }   
   
   

       ActivityThread类有一个类型为ActivityClientRecord的成员变量mNewActivities，用来描述所有在当前应用程序主线程中新启动起来的Activity组件。这些新启动起来的Activity组件通过ActivityClientRecord类的成员变量nextIdle连接在一起。一旦当前应用程序主线程向ActivityManagerService发送了这些新启动的Activity组件的空闲通知之后，这些新启动起来的Activity组件就不会再被保存在ActivityThread类的成员变量mNewActivities中了，即每一个新启动的Activity组件只有一次机会向ActivityManagerService发送一个空闲通知。

 

       向ActivityManagerService发送一个Activity组件空闲通知是通过调用ActivityManagerService代理对象的成员函数activityIdle来实现的，而ActivityManagerService代理对象可以通过调用ActivityManagerNative类的静态成员函数getDefault来获得。

       ActivityManagerService代理对象的类型为ActivityManagerProxy，它的成员函数activityIdle实现在文件frameworks/base/core/java/android/app/ActivityManagerNative.java中，如下所示：

 
 

   
   

    
    class ActivityManagerProxy implements IActivityManager   
   
   

   
   

    
    {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        public void activityIdle(IBinder token, Configuration config) throws RemoteException   
   
   

   
   

    
        {   
   
   

   
   

    
            Parcel data = Parcel.obtain();   
   
   

   
   

    
            Parcel reply = Parcel.obtain();   
   
   

   
   

    
            data.writeInterfaceToken(IActivityManager.descriptor);   
   
   

   
   

    
            data.writeStrongBinder(token);   
   
   

   
   

    
            if (config != null) {   
   
   

   
   

    
                data.writeInt(1);   
   
   

   
   

    
                config.writeToParcel(data, 0);   
   
   

   
   

    
            } else {   
   
   

   
   

    
                data.writeInt(0);   
   
   

   
   

    
            }   
   
   

   
   

    
            mRemote.transact(ACTIVITY_IDLE_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);   
   
   

   
   

    
            reply.readException();   
   
   

   
   

    
            data.recycle();   
   
   

   
   

    
            reply.recycle();   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }   
   
   

      ActivityManagerProxy类的成员函数activityIdle实际上是向ActivityManagerService发送一个类型为ACTIVITY_IDLE_TRANSACTION的Binder进程间通信请求，其中，参数token用来描述与这个进程间通信请求所关联的一个Activity组件，在我们这个场景中，这个Activity组件即为应用程序Launcher的根Activity组件Launcher。

 

        类型为ACTIVITY_IDLE_TRANSACTION的Binder进程间通信请求是由ActivityManagerService类的成员函数activityIdle来处理的，如下所示：

 
 

   
   

    
    public final class ActivityManagerService extends ActivityManagerNative   
   
   

   
   

    
            implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        public final void activityIdle(IBinder token, Configuration config) {   
   
   

   
   

    
            final long origId = Binder.clearCallingIdentity();   
   
   

   
   

    
            mMainStack.activityIdleInternal(token, false, config);   
   
   

   
   

    
            Binder.restoreCallingIdentity(origId);   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }   
   
   

    ActivityManagerService类有一个类型为ActivityStack的成员变量mMainStack，它用来描述系统的Activity组件堆栈，它的成员函数activityIdleInternal的实现如下所示：

 
 

   
   

    
    public class ActivityStack {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        final void activityIdleInternal(IBinder token, boolean fromTimeout,   
   
   

   
   

    
                Configuration config) {   
   
   

   
   

    
            ......   
   
   

   
   

    
       
   
   

   
   

    
            boolean enableScreen = false;   
   
   

   
   

    
       
   
   

   
   

    
            synchronized (mService) {   
   
   

   
   

    
                ......   
   
   

   
   

    
       
   
   

   
   

    
                // Get the activity record.   
   
   

   
   

    
                int index = indexOfTokenLocked(token);   
   
   

   
   

    
                if (index >= 0) {   
   
   

   
   

    
                    ActivityRecord r = (ActivityRecord)mHistory.get(index);                   
   
   

   
   

    
                    ......   
   
   

   
   

    
       
   
   

   
   

    
                    if (mMainStack) {   
   
   

   
   

    
                        if (!mService.mBooted && !fromTimeout) {   
   
   

   
   

    
                            mService.mBooted = true;   
   
   

   
   

    
                            enableScreen = true;   
   
   

   
   

    
                        }   
   
   

   
   

    
                    }   
   
   

   
   

    
                }   
   
   

   
   

    
       
   
   

   
   

    
                ......   
   
   

   
   

    
            }   
   
   

   
   

    
       
   
   

   
   

    
            ......   
   
   

   
   

    
       
   
   

   
   

    
            if (enableScreen) {   
   
   

   
   

    
                mService.enableScreenAfterBoot();   
   
   

   
   

    
            }   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }           
   
   

        参数token用来描述刚刚启动起来的Launcher组件，通过它来调用函数indexOfTokenLocked就可以得到Launcher组件在系统Activity组件堆栈中的位置index。得到了Launcher组件在系统Activity组件堆栈中的位置index之后，就可以在ActivityStack类的成员变量mHistory中得到一个ActivityRecord对象r。这个ActivityRecord对象r同样是用来描述Launcher组件的。

        ActivityStack类的成员变量mMainStack是一个布尔变量，当它的值等于true的时候，就说明当前正在处理的ActivityStack对象是用来描述系统的Activity组件堆栈的。 ActivityStack类的另外一个成员变量mService指向了系统中的ActivityManagerService服务。ActivityManagerService服务有一个类型为布尔值的成员变量mBooted，它的初始值为false，表示系统尚未启动完成。

        从前面的调用过程可以知道，参数fromTimeout的值等于false。在这种情况下，如果ActivityManagerService服务的成员变量mBooted也等于false，那么就说明应用程序已经启动起来了，即说明系统已经启动完成了。这时候ActivityManagerService服务的成员变量mBooted以及变量enableScreen的值就会被设置为true。

        当变量enableScreen的值等于true的时候，ActivityStack类就会调用ActivityManagerService服务的成员函数enableScreenAfterBoot停止显示开机动画，以便可以将屏幕让出来显示应用程序Launcher的界面。

        ActivityManagerService类的成员函数enableScreenAfterBoot的实现如下所示：

 
 

   
   

    
    public final class ActivityManagerService extends ActivityManagerNative   
   
   

   
   

    
            implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        void enableScreenAfterBoot() {   
   
   

   
   

    
            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN,   
   
   

   
   

    
                    SystemClock.uptimeMillis());   
   
   

   
   

    
            mWindowManager.enableScreenAfterBoot();   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }   
   
   

        ActivityManagerService类的成员变量mWindowManager指向了系统中的Window管理服务WindowManagerService，ActivityManagerService服务通过调用它的成员函数enableScreenAfterBoot来停止显示开机动画。

 

       WindowManagerService类的成员函数enableScreenAfterBoot的实现如下所示：

 
 

   
   

    
    public class WindowManagerService extends IWindowManager.Stub   
   
   

   
   

    
            implements Watchdog.Monitor {   
   
   

   
   

    
        ......   
   
   

   
   

    
       
   
   

   
   

    
        public void enableScreenAfterBoot() {   
   
   

   
   

    
            synchronized(mWindowMap) {   
   
   

   
   

    
                if (mSystemBooted) {   
   
   

   
   

    
                    return;   
   
   

   
   

    
                }   
   
   

   
   

    
                mSystemBooted = true;   
   
   

   
   

    
            }   
   
   

   
   

    
       
   
   

   
   

    
            performEnableScreen();   
   
   

   
   

    
        }   
   
   

   
   

    
       
   
   

   
   

    
        ......   
   
   

   
   

    
    }   
   
   

       WindowManagerService类的成员变量mSystemBooted用来记录系统是否已经启动完成的。如果已经启动完成的话，那么这个成员变量的值就会等于true，这时候WindowManagerService类的成员函数enableScreenAfterBoot什么也不做就返回了，否则的话，WindowManagerService类的成员函数enableScreenAfterBoot首先将这个成员变量的值设置为true，接着再调用另外一个成员函数performEnableScreen来执行停止显示开机动画的操作。