3.3 Zygote守护进程与system_server进程

Android的执行环境和Java执行环境有着本质的差别，在Android系统中每一个应用程序都是一独立的进程，当一个进程死掉时，不会影响其他进程的执行，这能极大的保证Android系统的稳定。 Zygote守护进程的启动是Android执行环境启动的開始阶段， Zygote进程通过Linux系统特有的Fork机制分裂克隆出全然相同的执行环境，全部的Android应用程序都是Zygote进程的子进程，system_server进程作为Zygote进程的嫡长子进程，对Android系统服务又有着重要意义。本节内容是我们研究Android系统启动的開始，让我们从Zygote守护进程的启动開始分析吧。

3.3.1 Zygote守护进程的启动

在init.rc中，通过init进程启动了Zygote服务：

service zygote/system/bin/app_process -Xzygote /system/bin –zygote –start-system-server

    socket zygote stream 666

……

通过上面init.rc的代码可知。Zygote服务相应程序为/system/bin/app_process。服务名为zygote，參数列表为：-Xzygote/system/bin –zygote –start-system-server。

在启动zygote 服务时，在/dev/socket/文件夹下建立一个streamsocket文件：zygote。权限为666。

我们能够通过以下的命令来查找Zygote进程的源代码：

find ./ -nameAndroid.mk  -exec grep -l app_process {}\;

注：find命令用于查找一个文件，-exec  xxx {} \;表示：在前面命令的结果里执行grep 命令。

由上述命令结果可知，Zygote进程代码为frameworks/base/cmds/app_process/app_main.cpp

找到该程序的main入口函数：

118 int main(int argc,const char* const argv[])

119 {

120     // These are global variables inProcessState.cpp

121     mArgC = argc;

122     mArgV = argv;

123

124     mArgLen = 0;

125     for (int i=0; i<argc; i++) {

126         mArgLen += strlen(argv[i]) + 1;

127     }

128     mArgLen–;

129

130     AppRuntimeruntime;

131     const char *arg;

132     const char *argv0;

133

134     argv0 = argv[0];

135

136     // Process command line arguments

137     // ignore argv[0]

138     argc–;

139     argv++;

141     // Everything up to ‘–‘ or first non ‘-‘arg goes to the vm

142     // 在zygote服务的參数列表中：/system/bin–zygote–start-system-server

           // 以“–”和非“-”开头的參数，是dalvik的參数，交给Vm来处理

143     int i = runtime.addVmArguments(argc, argv);

144

145     // 找到zygote的文件夹：/system/bin

146     if (i < argc) {

147         runtime.mParentDir = argv[i++];

148     }

149

150     // 假设接下来的參数是：–zygote –start-system-server的话，

// 设置argv0=“zygote”，startSystemServer= true，启动java VM

151     if (i < argc) {

152         arg = argv[i++];

153         if (0 == strcmp(“–zygote”,arg)) {

154             bool startSystemServer = (i <argc) ?

155                     strcmp(argv[i],”–start-system-server”) == 0 : false;

156             setArgv0(argv0,”zygote”);

157             set_process_name(“zygote”);

158             runtime.start(“com.android.internal.os.ZygoteInit”,

159                 startSystemServer);

160         } else {

161             set_process_name(argv0);

162

163             runtime.mClassName = arg;

164

165             // Remainder of args get passed tostartup class main()

166             runtime.mArgC = argc-i;

167             runtime.mArgV = argv+i;

168

169             LOGV(“App process is startingwith pid=%d, class=%s.\n”,

170                  getpid(), runtime.getClassName());

171             runtime.start();

172         }

173     } else {

174         LOG_ALWAYS_FATAL(“app_process: noclass name or –zygote supplied.”);

175         fprintf(stderr, “Error: no classname or –zygote supplied.\n”);

176         app_usage();

177         return 10;

178     }

179

180 }

依据service zygote的參数，启动Android执行时环境：

runtime.start(“com.android.internal.os.ZygoteInit”,startSystemServer)，依据前面的分析可知：startSystemServer= true，runtime是AppRuntime的对象。AppRuntime是AndroidRuntime的子类，如图xx-xx所看到的：

图 xx-xx AndroidRuntime与AppRuntime类关系图

由上面类图可知，runtime.start方法在AndroidRuntime里实现：

@frameworks/base/core/jni/AndroidRuntime.cpp

883 void AndroidRuntime::start(const char*className, const bool startSystemServer)

 884{

             // logcat里最显眼的字样

 885    LOGD(“\n>>>>>> AndroidRuntime START %s<<<<<<\n”,

 886            className != NULL ? className : “(unknown)”);

 887

 888    char* slashClassName = NULL;

 889    char* cp;

 890    JNIEnv* env;

 891

             // 启动Dalvik虚拟机。在AndroidRuntime::startVm方法中。设置了大量VM的启动參数。

             // 最后通过JNI调用JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs)函数启动虚拟机

 918    /* start the virtual machine */

 919    if (startVm(&mJavaVM, &env) != 0)

 920        goto bail;

 921

 922    /*

 923     * Register android functions.   //注冊系统使用的JNI函数

 924     */                                                                                                                         

 925    if (startReg(env) < 0) {

 926        LOGE(“Unable to register all android natives\n”);

 927        goto bail;

 928    }

930    /*

 931     * We want to call main() with a String array with arguments in it.

 932     * At present we only have one argument, the class name.  Create an

 933     * array to hold it.

 934     */

 935    jclass stringClass;

 936    jobjectArray strArray;

 937    jstring classNameStr;

 938    jstring startSystemServerStr;

 939

             // 从虚拟机执行环境里，查找到String类

 940    stringClass = env->FindClass(“java/lang/String”); 

 941    assert(stringClass != NULL);

             // 创建一个String数组，有两个元素（strArray =  new String[2]）

 942    strArray = env->NewObjectArray(2, stringClass, NULL);

 943    assert(strArray != NULL);

             // 创建一个Java String对象，初始值为：className的值，

            // 即：“com.android.internal.os.ZygoteInit”

 944    classNameStr = env->NewStringUTF(className);

 945    assert(classNameStr != NULL);

             // 设置strArray 第一个元素的值为：classNameStr(strArray[0] = classNameStr)

 946    env->SetObjectArrayElement(strArray, 0, classNameStr);

             // 创建一个Java String对象，初始值为：startSystemServer的值，即：“true”

 947    startSystemServerStr = env->NewStringUTF(startSystemServer ?

 948                                                 “true” : “false”);                    

             // 设置strArray 第二个元素的值为：strArray[1]=startSystemServerStr                          

 949    env->SetObjectArrayElement(strArray, 1, startSystemServerStr);

           // 依据上面的解释。我们能够用以下的Java代码来表示：

           // String[] strArray = new strArray[2];

           // strArray[0]  =”com.android.internal.os.ZygoteInit”

           // strArray[1]  = “true”

 950

 951    /*

 952     * Start VM.  This thread becomesthe main thread of the VM, and will

 953     * not return until the VM exits.

 954     */

 955    jclass startClass;

 956    jmethodID startMeth;

 957

 958    slashClassName = strdup(className);

 959    for (cp = slashClassName; *cp != ‘\0’; cp++)

 960        if (*cp == ‘.’)

 961            *cp = ‘/’;

           // 将com.android.internal.os.ZygoteInit中的包分隔符“.”换成“/”

           // 即：slashClassName =”com/android/internal/os/ZygoteInit”

 962

 963    startClass = env->FindClass(slashClassName);

           // 从VM中查找ZygoteInit类。难道它要在VM里执行这个它？

 964    if (startClass == NULL) {

 965        LOGE(“JavaVM unable to locate class ‘%s’\n”, slashClassName);

 966        /* keep going */

 967    } else {

 968        startMeth = env->GetStaticMethodID(startClass, “main”,                                                                  

 969            “([Ljava/lang/String;)V”);

                 // 从ZygoteInit类中查找名字为main的静态方法。

                 // 而且main方法有一个參数String[]。返回值为void。

                 // 这不就是Java应用程序的main函数的签名吗？难道要调用它？？

 970        if (startMeth == NULL) {

 971            LOGE(“JavaVM unable to find main() in ‘%s’\n”, className);

 972            /* keep going */

 973        } else {

 974            env->CallStaticVoidMethod(startClass, startMeth, strArray);

                     // 果然，调用了ZygoteInit类里的main方法。

这不就是在VM里执行ZygoteInit程序吗。！

980        }

 981    }

… 省略部分代码…

 991 }

由上面的分析简单总结下：

从源代码的角度在AndroidRuntime::start方法实现了以下功能：

  1>通过startVm来启动Dalvik虚拟机（简称DVM），而且注冊了一些本地JNI函数，因为这个时候DVM里还没有程序，仅仅是个空的DVM执行环境

  2>通过AndroidRuntime::start的參数，在JNI代码里执行第一个Java程序ZygoteInit，将其作为DVM的主线程，同一时候给它传递两个在JNI中构建的參数：

“com/android/internal/os/ZygoteInit”和”true”

我们再从进程的角度来分析下：

Zygote进程由init进程作为Service启动。在Zygote进程里通过startVm启动了VM执行环境（如图xx-xx中①所看到的），通过JNI代码在VM环境中执行ZygoteInit.java。作为VM中的主线程。

图 xx-xx Zygote进程与Dalvik虚拟机

3.3.2 ZygoteInit类的功能与system_server进程的创建

Zygote将DVM执行环境准备好了。而且開始调用执行ZygoteInit.java代码。

以下我们分析下ZygoteInit.java代码。

@frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

554     public static void main(String argv[]) {

555         try {

                    … 省略部分代码…

561             registerZygoteSocket();  // 注冊ZygoteSocket。创建一个Socket的服务端

… 省略部分代码…

564             preloadClasses();            // 预载入类

565             //cacheRegisterMaps();

566             preloadResources();       // 预资源类

… 省略部分代码…

                    // 假设ZygoteInit的第二个參数为”true”。则调用startSystemServer()

581             if(argv[1].equals(“true”)) {

582                 startSystemServer();

583             } else if(!argv[1].equals(“false”)) {

584                 throw newRuntimeException(argv[0] + USAGE_STRING);

585             }

… 省略部分代码…

603     }

依据main函数的第二个參数。调用了startSystemServer：

508     private static boolean startSystemServer()

511         String args[] = {

512             “–setuid=1000”,

513             “–setgid=1000”,

514″–setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003″,

515            “–capabilities=130104352,130104352”,

516             “–runtime-init”,

517             “–nice-name=system_server”,

518            “com.android.server.SystemServer”,

519         };

520         ZygoteConnection.Arguments parsedArgs= null;

521

522         int pid;

523                                                              

524         try {

                    // 创建ZygoteConnection的内部类Arguments，它是ZygoteSocketclient的參数封装类

                    // 在Arguments的构造方法里对args[]进行了解析，以下Zygote.forkSystemServer会用到。

525             parsedArgs = newZygoteConnection.Arguments(args);

… 省略部分代码…

536             /* Request to fork the system server process*/

537             pid = Zygote.forkSystemServer(

538                     parsedArgs.uid,parsedArgs.gid,

539                     parsedArgs.gids,debugFlags, null,

540                     parsedArgs.permittedCapabilities,

541                    parsedArgs.effectiveCapabilities);       

                    // 调用Zygote的静态方法forkSystemServer（）。用来创建了一个

                    // 名字为system_server的进程。该方法是一个本地方法

                    // 在libcore/dalvik/src/main/java/dalvik/system/Zygote.java里定义。

                    // 本地实如今dalvik/vm/native/dalvik_system_Zygote.c中

542         } catch (IllegalArgumentException ex){

543             throw new RuntimeException(ex);

544         }

545

546         /* For child process */

547         if (pid == 0) {

548            handleSystemServerProcess(parsedArgs);

549         }

550

551         return true;

552     }

通过Zygote.forkSystemServer方法克隆了一个新的进程system_server。除了进程ID号pid它和Zygote进程的代码和数据全然一样，关于克隆具体内容，请查看fork系统调用相关知识。

在新创建的子进程system_server中调用handleSystemServerProcess：

491     private static voidhandleSystemServerProcess(

492             ZygoteConnection.ArgumentsparsedArgs)

493             throwsZygoteInit.MethodAndArgsCaller {

494

                // 在新创建的子进程里将ZygoteSocket关闭

495         closeServerSocket();

… 省略部分代码…

                // 将”–nice-name=system_server,com.android.server.SystemServer”传递给RuntimeInit.zygoteInit（）

                // 在RuntimeInit.zygoteInit方法里，调用了SystemServer的main方法，即在新进程里执行SystemServer.java

501        RuntimeInit.zygoteInit(parsedArgs.remainingArgs);                                                                        

502         /* should never reach here */

503     }

至此。Zygote的第一个嫡长子进程system_server创建完成，而且開始执行其main方法，我们做下总结，如图xx-xx所看到的。

图 xx-xx  system_server进程的创建

①：在Zygote进程通过startVm启动Dalvik虚拟机（简称DVM）。在DVM里通过JNI调用ZygoteInit.main()，启动DVM里第一个主线程。

②：在ZygoteInit.java中绑定了ZygoteSocket并预载入类和资源。

③：通过Zygote.forkSystemServer（）本地方法。在Linux中分裂fork出Zygote的第一个子进程。取名为system_server，该进程中的代码和数据与父进程Zygote全然一样。

④：在Zygote进程中通过RuntimeInit.zygoteInit()，调用SystemServer.main()。从而在system_server中执行SystemServer.java代码。

在Zygote进程创建时，init.rc脚本中创建了/dev/socket/zygote文件，它在ZygoteInit中被绑定为服务器端，用来接收克隆Zygote进程的请求，它相应用程序的创建有着重要的意义，其创建步骤例如以下图所看到的：

图 xx-xx  应用程序的创建

①  Zygote进程绑定并通过select监听ZygoteSocket（/dev/socket/zygote）

②  其他进程发出socket连接请求，用于创建新应用程序

③  Zygote和请求发起者建立新连接用于通信。接收待创建应用程序信息

④：Zygote进程依据client数据请求Fork出新的子进程

在ZygoteInit中预载入类和预加资源对Android整个执行环境有着至关重要的意义，预载入的类是指大量的Android框架层代码。这些类有数千个，当Android应用程序执行时都要载入这些类，相同的预载入资源是指一些系统的图片、图标、字符串资源。

假设这些类和资源推迟到Android应用程序启动时。那么应用程序的启动速度会大大减少，会直接影响用户体验，Android充分利用了Linux中fork进程时会克隆父进程数据和代码的特点。将类和资源提前载入到父进程里，从而大大提高了启动速度。

3.3.3 system_server进程的执行

@frameworks/base/services/java/com/android/server/SystemServer.java

596    native public static void init1(String[] args);   // init1方法为本地方法

598    public static void main(String[] args) {

               … 省略部分代码…

               // 载入本地库android_servers，添头加尾后本地库文件名称为：libandroid_servers.so

624        System.loadLibrary(“android_servers”);

625        init1(args);

626     }

在system_server进程里载入了libandroid_servers.so本地库。依据JNI机制，当Java代码中通过System.load载入一个本地动态库时，会自己主动调用该动态库中的JNI_Onload方法。通常在JNI_Onload方法中注冊本地函数与Java方法映射关系：

@frameworks/base/services/jni/onload.cpp

20 extern “C” jint JNI_OnLoad(JavaVM*vm, void* reserved)

 21 {

 22     JNIEnv* env = NULL;

 23     jint result = -1;

 24

 25     if (vm->GetEnv((void**) &env,JNI_VERSION_1_4) != JNI_OK) {

 26         LOGE(“GetEnv failed!”);

 27         return result;

 28     }

 29     LOG_ASSERT(env, “Could not retrievethe env!”);

 30

 31    register_android_server_PowerManagerService(env);

 32     register_android_server_InputManager(env);

 33    register_android_server_LightsService(env);

 34    register_android_server_AlarmManagerService(env);

 35    register_android_server_BatteryService(env);

 36     register_android_server_UsbService(env);

 37    register_android_server_VibratorService(env);

 38     register_android_server_SystemServer(env);// 它实如今com_android_server_SystemServer.cpp中

 39    register_android_server_location_GpsLocationProvider(env);

 40

 41     return JNI_VERSION_1_4;

 42 }

@frameworks/base/services/jni/com_android_server_SystemServer.cpp

 22namespace android {

 23

 24 extern”C” int system_init();

 25

 26 staticvoid android_server_SystemServer_init1(JNIEnv* env, jobject clazz)

 27 {

 28     system_init();// 被SystemServer.java调用。在frameworks/base/cmds/system_server/library/system_init.cpp中实现

            // system_init.cpp被编译成libsystem_server.so库。被libandroid_servers.so引用

 29 }

 30

 31 /*

 32  * JNI registration.

 33  */

      // 由此可见。SystemServer.java中调用的init1方法，映射到了android_server_SystemServer_init1方法

 34 staticJNINativeMethod gMethods[] = {

 35     /* name, signature, funcPtr */

 36     { “init1″,”([Ljava/lang/String;)V”, (void*) android_server_SystemServer_init1},

 37 };

 38  // 该方法被frameworks/base/services/jni/onload.cpp回调，用来注冊本地方法与Java方法的映射

 39 intregister_android_server_SystemServer(JNIEnv* env)

 40 {

 41     return jniRegisterNativeMethods(env,”com/android/server/SystemServer”,

 42             gMethods, NELEM(gMethods));

 43 }

 44

 45 }; //namespace android

在register_android_server_SystemServer方法中注冊本地方法与Java方法，通过映射关系可知，Java层的init1方法调用了本地的system_init方法：

@frameworks/base/cmds/system_server/library/system_init.cpp

 54 extern”C” status_t system_init()

 55 {

 56     LOGI(“Entered system_init()”);

          … 省略部分代码…

 66     char propBuf[PROPERTY_VALUE_MAX];

 67    property_get(“system_init.startsurfaceflinger”, propBuf,”1″);

 68     if (strcmp(propBuf, “1”) == 0) {

 69         // Start the SurfaceFlinger

 70         SurfaceFlinger::instantiate(); //  启动SurfaceFlinger本地系统服务

 71     }

 72

 73     // Start the sensor service

 74     SensorService::instantiate();        // 启动SensorService本地系统服务

           … 省略部分代码…

99    LOGI(“System server: starting Android runtime.\n”);

100

101    AndroidRuntime* runtime = AndroidRuntime::getRuntime();

102

103    LOGI(“System server: starting Android services.\n”);

104    runtime->callStatic(“com/android/server/SystemServer”,”init2″);  // 调用Java环境中SystemServer.java的init2方法

           … 省略部分代码…

115    return NO_ERROR;

116 }

在system_init方法里开启了几个本地系统服务：SurfaceFlinger和SensorService，然后从本地又调回了Java执行环境中的SystemServer.java中的init2方法。之所以这么做，原因是上层Android系统服务的执行要依赖于本地系统服务的执行。所以system_server先保障本地服务的执行，然后再回执行Android系统服务。

SystemServer.java中的init2方法执行：

628    public static final void init2() {

629        Slog.i(TAG, “Entered the Android system server!”);

630        Thread thr = new ServerThread();

631        thr.setName(“android.server.ServerThread”);

632        thr.start();

633     }

在init2中创建并开启了一个线程ServerThread，在线程的Run方法中

59 class ServerThread extends Thread {

        … 省略部分代码…

80    @Override 

81    public void run() {

            // 开启主线程消息队列

85        Looper.prepare();

             … 省略部分代码…

131        // Critical services…

132        try {

//加入Android系统服务

133            Slog.i(TAG, “Entropy Service”);

134            ServiceManager.addService(“entropy”, new EntropyService());

//加入Android系统服务

136            Slog.i(TAG, “Power Manager”);

137            power = new PowerManagerService();

138            ServiceManager.addService(Context.POWER_SERVICE, power);

//加入Android系统服务

140            Slog.i(TAG, “Activity Manager”);

141            context = ActivityManagerService.main(factoryTest);

//加入Android系统服务

143            Slog.i(TAG, “TelephonyRegistry”);

144            ServiceManager.addService(“telephony.registry”, newTelephonyRegistry(context));

145

                   … 省略部分代码。加入了大量Android系统服务…

473        // It is now time to start up the app processes…

474

475        if (devicePolicy != null) {

476            devicePolicy.systemReady();

477        }

478

479        if (notification != null) {

480            notification.systemReady();

481        }

482

483        if (statusBar != null) {

484            statusBar.systemReady();

485        }

486        wm.systemReady();

487        power.systemReady();

488        try {

489            pm.systemReady();

490        } catch (RemoteException e) {

491        }

              … 省略部分代码…

507        // We now tell the activitymanager it is okay to run third party

508        // code.  It will call back intous once it has gotten to the state

509        // where third party code can really run (but before it has actually

510        // started launching the initial applications), for us to complete our

511        // initialization.

512        ((ActivityManagerService)ActivityManagerNative.getDefault())

513                 .systemReady(new Runnable(){     // 调用ActivityManagerService的systemReady。通知系统准备就绪。

…省略部分代码…

              });

542        Looper.loop();   // system_service主线程队列開始循环等待消息

543        Slog.d(TAG, “System ServerThread is exiting!”);

544     }

545 }

由前面分析可知，system_server进程的主要作用就是启动并执行Android系统服务，这些服务执行在system_server进程中，由此可见其重要性。

图x-x system_server进程

Android系统中服务分为两种：本地服务和Android系统服务，我们将Android2.3系统中这些服务分别罗列出来。以供參考。

Ø 本地服务主要包括：

Ø Android系统服务：

3.3.4Home桌面的启动

当Android系统服务启动完成后。system_service进程会通知Android系统服务系统启动完成，在ActivityManagerService.systemReady方法里会启动Android系统桌面应用程序：launcher。

@frameworks/base/services/java/com/android/server/am/ActivityManagerService.java

  386     public ActivityStack mMainStack;

            … 省略部分代码…

6089    public void systemReady(final Runnable goingCallback) {

              … 省略部分代码…

6254        synchronized (this) {

                     … 省略部分代码…

6288            mMainStack.resumeTopActivityLocked(null);   //  在Activity栈中显示栈顶的Activity画面

6289        }

6290     }

在ActivityManagerService中维护了一个ActivityStack，它用来管理Activity的执行状态，在栈顶的Activity即是正在执行的画面，当ActivityManagerService准备就绪后。显示ActivityStack中栈顶画面。

@frameworks/base/services/java/com/android/server/am/ActivityStack.java

125    final ActivityManagerService mService;

…省略部分代码…

1051    final boolean resumeTopActivityLocked(ActivityRecord prev) {

1052        // Find the first activity that is not finishing.

                // 返回ActivityStack栈顶的Activity，因为刚启动Android系统，所以返回null

1053        ActivityRecord next = topRunningActivityLocked(null);

…省略部分代码…

1060        if (next == null) {

1061            // There are no more activities! Let’s just start up the

1062            // Launcher…

1063            if (mMainStack) {

1064                 return mService.startHomeActivityLocked();  // 假设Activity栈顶没有Activity，则启动Launcher。即：HOME

1065            }

1066        }

         因为Android系统刚启动，ActivityStack栈中还没有不论什么执行的Activity，所以这时要启动HOME应用程序作为主画面，从而显示桌面应用程序。

         在Android中，启动一个Activity有两种方式：显示Intent启动和隐式Intent启动。

显示Intent启动：在Intent对象中指定Intent对象的接收者。是点对点的启动方式。

隐式Intent启动：相似于广播机制。在发送的Intent中通过Action和Category来匹配接收者，因此在Android系统中同意发出的Intent对象启动多个Activity，这样的方式保证了Android中全部应用程序的公平性。

         Android的HOME应用程序的启动是通过隐式Intent启动的，我们能够查看HOME应用程序的AndroidManifest.xml文件来确定它的Intent对象的匹配内容：

@packages/apps/Launcher2/AndroidManifest.xml

  1<?xml version=”1.0″ encoding=”utf-8″?>

… 省略部分代码…

20 <manifest

 21    xmlns:android=”http://schemas.android.com/apk/res/android”

 22     package=”com.android.launcher”

 23    android:sharedUserId=”@string/sharedUserId”

 24     >

65    <application

 66        android:name=”com.android.launcher2.LauncherApplication”

 67        android:process=”@string/process”

 68        android:label=”@string/application_name”

 69        android:icon=”@drawable/ic_launcher_home”>

 70

 71         <activity

 72            android:name=”com.android.launcher2.Launcher”

 73            android:launchMode=”singleTask”

 74            android:clearTaskOnLaunch=”true”

 75            android:stateNotNeeded=”true”

 76             android:theme=”@style/Theme”

 77            android:screenOrientation=”nosensor”

 78            android:windowSoftInputMode=”stateUnspecified|adjustPan”>

 79            <intent-filter>

 80                 <actionandroid:name=”android.intent.action.MAIN” />

 81                 <categoryandroid:name=”android.intent.category.HOME” />

 82                 <categoryandroid:name=”android.intent.category.DEFAULT” />

 83                 <categoryandroid:name=”android.intent.category.MONKEY”/>

 84            </intent-filter>

 85         </activity>

在Android系统启动的终于阶段通过Intent对象启动HOME应用程序，该Intent中封装了两个基本的属性：action=”android.intent.action.MAIN”。category=“android.intent.category.HOME”。通过上面的代码能够看出来，launcher2应用程序的intent-filter匹配项里包括了HOME应用程序启动的“必要条件”。