学步园

Step1、

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

[java] view
plaincopy

1. public class SystemServer  
2. {  
3.     ......  
4.   
5.     public static final void init2() {  
6.         Slog.i(TAG, "Entered the Android system server!");  
7.         Thread thr = new ServerThread();  
8.         thr.setName("android.server.ServerThread");  
9.         thr.start();  
10.     }  
11. }  

        这个函数创建了一个ServerThread线程，PackageManagerService服务就是这个线程中启动的了。这里调用了ServerThread实例thr的start函数之后，下面就会执行这个实例的run函数了。

        这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

[java] view
plaincopy

1. class ServerThread extends Thread {  
2.     ......  
3.   
4.     @Override  
5.     public void run() {  
6.         ......  
7.   
8.         IPackageManager pm = null;  
9.   
10.         ......  
11.   
12.         Slog.i(TAG, "Activity Manager");
13.         context = ActivityManagerService.main(factoryTest);
14.         
15.         ......
16.         ActivityManagerService.setSystemProcess();//设为系统进程
17.         ......  
18.     }  
19.   
20.     ......  
21. }  

        这个函数除了启动ActivityManagerService服务之外，还启动了其它很多的服务

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

[java] view
plaincopy

1. public final class ActivityManagerService extends ActivityManagerNative  
2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
3.     ......  
4.   
5.     public static final Context main(int factoryTest) {  
6.         AThread thr = new AThread();  
7.         thr.start();  
8.   
9.         synchronized (thr) {  
10.             while (thr.mService == null) {  
11.                 try {  
12.                     thr.wait();  
13.                 } catch (InterruptedException e) {  
14.                 }  
15.             }  
16.         }  
17.   
18.         ActivityManagerService m = thr.mService;  
19.         mSelf = m;  
20.         ActivityThread at = ActivityThread.systemMain();  
21.         mSystemThread = at;  
22.         Context context = at.getSystemContext();  
23.         m.mContext = context;  
24.         m.mFactoryTest = factoryTest;  
25.         m.mMainStack = new ActivityStack(m, context, true);  
26.   
27.         m.mBatteryStatsService.publish(context);  
28.         m.mUsageStatsService.publish(context);  
29.   
30.         synchronized (thr) {  
31.             thr.mReady = true;  
32.             thr.notifyAll();  
33.         }  
34.   
35.         m.startRunning(null, null, null, null);  
36.   
37.         return context;  
38.     }  
39.   
40.     ......  
41. }  

        这个函数首先通过AThread线程对象来内部创建了一个ActivityManagerService实例，然后将这个实例保存其成员变量mService中，接着又把这个ActivityManagerService实例保存在ActivityManagerService类的静态成员变量mSelf中，最后初始化其它成员变量，就结束了。

        这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中，执行完这一步之后，系统中的应用程序的所有信息都保存在PackageManagerService中了，后面Home应用程序Launcher启动起来后，就会把PackageManagerService中的应用程序信息取出来，然后以快捷图标的形式展示在桌面上，后面我们将会看到这个过程。

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

[java] view
plaincopy

1. public final class ActivityManagerService extends ActivityManagerNative  
2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
3.     ......  
4.   
5.     public static void setSystemProcess() {  
6.         try {  
7.             ActivityManagerService m = mSelf;  
8.   
9.             ServiceManager.addService("activity", m);  
10.             ServiceManager.addService("meminfo", new MemBinder(m));  
11.             if (MONITOR_CPU_USAGE) {  
12.                 ServiceManager.addService("cpuinfo", new CpuBinder(m));  
13.             }  
14.             ServiceManager.addService("permission", new PermissionController(m));  
15.   
16.             ApplicationInfo info =  
17.                 mSelf.mContext.getPackageManager().getApplicationInfo(  
18.                 "android", STOCK_PM_FLAGS);  
19.             mSystemThread.installSystemApplicationInfo(info);  
20.   
21.             synchronized (mSelf) {  
22.                 ProcessRecord app = mSelf.newProcessRecordLocked(  
23.                     mSystemThread.getApplicationThread(), info,  
24.                     info.processName);  
25.                 app.persistent = true;  
26.                 app.pid = MY_PID;  
27.                 app.maxAdj = SYSTEM_ADJ;  
28.                 mSelf.mProcessNames.put(app.processName, app.info.uid, app);  
29.                 synchronized (mSelf.mPidsSelfLocked) {  
30.                     mSelf.mPidsSelfLocked.put(app.pid, app);  
31.                 }  
32.                 mSelf.updateLruProcessLocked(app, true, true);  
33.             }  
34.         } catch (PackageManager.NameNotFoundException e) {  
35.             throw new RuntimeException(  
36.                 "Unable to find android system package", e);  
37.         }  
38.     }  
39.     ......  
40. }  

        这个函数首先是将这个ActivityManagerService实例添加到ServiceManager中去托管，这样其它地方就可以通过ServiceManager.getService接口来访问这个全局唯一的ActivityManagerService实例了，接着又通过调用mSystemThread.installSystemApplicationInfo函数来把应用程序框架层下面的android包加载进来
，这里的mSystemThread是一个ActivityThread类型的实例变量，它是在上一步中创建的，后面就是一些其它的初始化工作了。

Step2、

        ServerThread.run函数在将系统中的一系列服务都初始化完毕之后才调用的systemReady（）

它定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

[java] view
plaincopy

1. public final class ActivityManagerService extends ActivityManagerNative  
2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
3.     ......  
4.   
5.     public void systemReady(final Runnable goingCallback) {  
6.         ......  
7.   
8.         synchronized (this) {  
9.             ......  
10.   
11.             mMainStack.resumeTopActivityLocked(null);  
12.         }  
13.     }  
14.   
15.     ......  
16. }  

        这个函数的内容比较多，这里省去无关的部分，主要关心启动Home应用程序的逻辑，这里就是通过mMainStack.resumeTopActivityLocked函数来启动Home应用程序的了，这里的mMainStack是一个ActivityStack类型的实例变量。

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java] view
plaincopy

1. public class ActivityStack {  
2.     ......  
3.   
4.     final boolean resumeTopActivityLocked(ActivityRecord prev) {  
5.         // Find the first activity that is not finishing.  
6. //返回的是当前系统Activity堆栈最顶端的Activity
7.         ActivityRecord next = topRunningActivityLocked(null);  
8.   
9.         ......  
10.   
11.         if (next == null) {  
12.             // There are no more activities!  Let's just start up the  
13.             // Launcher...  
14.             if (mMainStack) {  
15.                 return mService.startHomeActivityLocked();  
16.             }  
17.         }  
18.   
19.         ......  
20.     }  
21.   
22.     ......  
23. }  

        这里调用函数topRunningActivityLocked返回的是当前系统Activity堆栈最顶端的Activity，由于此时还没有Activity被启动过，因此，返回值为null，即next变量的值为null，于是就调用mService.startHomeActivityLocked语句，这里的mService就是前面创建的ActivityManagerService实例了。

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

[java] view
plaincopy

1. public final class ActivityManagerService extends ActivityManagerNative  
2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
3.     ......  
4.   
5.     boolean startHomeActivityLocked() {  
6.         ......  
7.   
8.         Intent intent = new Intent(  
9.             mTopAction,  
10.             mTopData != null ? Uri.parse(mTopData) : null);  
11.         intent.setComponent(mTopComponent);  
12.         if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {  
13.             intent.addCategory(Intent.CATEGORY_HOME);  
14.         }  
15.         ActivityInfo aInfo =  
16.             intent.resolveActivityInfo(mContext.getPackageManager(),  
17.             STOCK_PM_FLAGS);  
18.         if (aInfo != null) {  
19.             intent.setComponent(new ComponentName(  
20.                 aInfo.applicationInfo.packageName, aInfo.name));  
21.             // Don't do this if the home app is currently being  
22.             // instrumented.  
23.             ProcessRecord app = getProcessRecordLocked(aInfo.processName,  
24.                 aInfo.applicationInfo.uid);  
25.             if (app == null || app.instrumentationClass == null) {  
26.                 intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);  
27.                 mMainStack.startActivityLocked(null, intent, null, null, 0, aInfo,  
28.                     null, null, 0, 0, 0, false, false);  
29.             }  
30.         }  
31.   
32.         return true;  
33.     }  
34.   
35.     ......  
36. }  

        函数首先创建一个CATEGORY_HOME类型的Intent，然后通过Intent.resolveActivityInfo函数向PackageManagerService查询Category类型为HOME的Activity，这里我们假设只有系统自带的Launcher应用程序注册了HOME类型的Activity（见packages/apps/Launcher2/AndroidManifest.xml文件）：

[html] view
plaincopy

1. <manifest  
2.     xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.android.launcher"  
4.     android:sharedUserId="@string/sharedUserId"  
5.     >  
6.   
7.     ......  
8.   
9.     <application  
10.         android:name="com.android.launcher2.LauncherApplication"  
11.         android:process="@string/process"  
12.         android:label="@string/application_name"  
13.         android:icon="@drawable/ic_launcher_home">  
14.   
15.         <activity  
16.             android:name="com.android.launcher2.Launcher"  
17.             android:launchMode="singleTask"  
18.             android:clearTaskOnLaunch="true"  
19.             android:stateNotNeeded="true"  
20.             android:theme="@style/Theme"  
21.             android:screenOrientation="nosensor"  
22.             android:windowSoftInputMode="stateUnspecified|adjustPan">  
23.             <intent-filter>  
24.                 <action android:name="android.intent.action.MAIN" />  
25.                 <category android:name="android.intent.category.HOME" />  
26.                 <category android:name="android.intent.category.DEFAULT" />  
27.                 <category android:name="android.intent.category.MONKEY"/>  
28.                 </intent-filter>  
29.         </activity>  
30.   
31.         ......  
32.     </application>  
33. </manifest>  

        因此，这里就返回com.android.launcher2.Launcher这个Activity了。由于是第一次启动这个Activity，接下来调用函数getProcessRecordLocked返回来的ProcessRecord值为null，于是，就调用mMainStack.startActivityLocked函数启动com.android.launcher2.Launcher这个Activity了，这里的mMainStack是一个ActivityStack类型的成员变量。

      
 ActivityStack.startActivityLocked 这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中，具体可以参考Android应用程序启动过程源代码分析一文，这里就不详述了，在我们这个场景中，调用这个函数的最后结果就是把com.android.launcher2.Launcher启动起来，接着调用它的onCreate函数。

Step3、执行Launcher.onCreate()

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/Launcher.java文件中：

[java] view
plaincopy

1. public final class Launcher extends Activity  
2.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
3.     ......  
4.   
5.     @Override  
6.     protected void onCreate(Bundle savedInstanceState) {  
7.         ......  
8.   
9.         if (!mRestoring) {  
10.             mModel.startLoader(this, true);  
11.         }  
12.   
13.         ......  
14.     }  
15.   
16.     ......  
17. }  

        这里的mModel是一个LauncherModel类型的成员变量，这里通过调用它的startLoader成员函数来执行加应用程序的操作。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

[java] view
plaincopy

1. public class LauncherModel extends BroadcastReceiver {  
2.     ......  
3.   
4.     public void startLoader(Context context, boolean isLaunching) {  
5.         ......  
6.   
7.                 synchronized (mLock) {  
8.                      ......  
9.   
10.                      // Don't bother to start the thread if we know it's not going to do anything  
11.                      if (mCallbacks != null && mCallbacks.get() != null) {  
12.                          // If there is already one running, tell it to stop.  
13.                          LoaderTask oldTask = mLoaderTask;  
14.                          if (oldTask != null) {  
15.                              if (oldTask.isLaunching()) {  
16.                                  // don't downgrade isLaunching if we're already running  
17.                                  isLaunching = true;  
18.                              }  
19.                              oldTask.stopLocked();  
20.                  }  
21.                  mLoaderTask = new LoaderTask(context, isLaunching);  
22.                  sWorker.post(mLoaderTask);  
23.                 }  
24.            }  
25.     }  
26.   
27.     ......  
28. }  

        这里不是直接加载应用程序，而是把加载应用程序的操作作为一个消息来处理。这里的sWorker是一个Handler，通过它的post方式把一个消息放在消息队列中去，然后系统就会调用传进去的参数mLoaderTask的run函数来处理这个消息，这个mLoaderTask是LoaderTask类型的实例，于是，下面就会执行LoaderTask类的run函数了。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

[java] view
plaincopy

1. public class LauncherModel extends BroadcastReceiver {  
2.     ......  
3.   
4.     private class LoaderTask implements Runnable {  
5.         ......  
6.   
7.         public void run() {  
8.             ......  
9.   
10.             keep_running: {  
11.                 ......  
12.   
13.                 // second step  
14.                 if (loadWorkspaceFirst) {  
15.                     ......  
16.                     loadAndBindAllApps();  
17.                 } else {  
18.                     ......  
19.                 }  
20.   
21.                 ......  
22.             }  
23.   
24.             ......  
25.         }  
26.   
27.         ......  
28.     }  
29.   
30.     ......  
31. }  

        这里调用loadAndBindAllApps成员函数来进一步操作。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

[java] view
plaincopy

1. public class LauncherModel extends BroadcastReceiver {  
2.     ......  
3.   
4.     private class LoaderTask implements Runnable {  
5.         ......  
6.   
7.         private void loadAndBindAllApps() {  
8.             ......  
9.   
10.             if (!mAllAppsLoaded) {  
11.                 loadAllAppsByBatch();  
12.                 if (mStopped) {  
13.                     return;  
14.                 }  
15.                 mAllAppsLoaded = true;  
16.             } else {  
17.                 onlyBindAllApps();  
18.             }  
19.         }  
20.   
21.   
22.         ......  
23.     }  
24.   
25.     ......  
26. }  

        由于还没有加载过应用程序，这里的mAllAppsLoaded为false，于是就继续调用loadAllAppsByBatch函数来进一步操作了。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

[java] view
plaincopy

1. public class LauncherModel extends BroadcastReceiver {  
2.     ......  
3.   
4.     private class LoaderTask implements Runnable {  
5.         ......  
6.   
7.         private void loadAllAppsByBatch() {   
8.             ......  
9. //函数首先构造一个CATEGORY_LAUNCHER类型的Intent：
10.             final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);  
11.             mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);  
13. //接着从mContext变量中获得PackageManagerService的接口
14.             final PackageManager packageManager = mContext.getPackageManager();  
15.             List<ResolveInfo> apps = null;  
16.   
17.             int N = Integer.MAX_VALUE;  
18.   
19.             int startIndex;  
20.             int i=0;  
21.             int batchSize = -1;  
22.             while (i < N && !mStopped) {  
23.                 if (i == 0) {  
24.                     mAllAppsList.clear();  
25.                     ......  
26. //从包信息中取回所有Action类型为Intent.ACTION_MAIN并且Category类型为Intent.CATEGORY_LAUNCHER的Activity
27.                     apps = packageManager.queryIntentActivities(mainIntent, 0);  
28.                       
29.                     ......  
30.   
31.                     N = apps.size();  
32.                       
33.                     ......  
34.   
35.                     if (mBatchSize == 0) {  
36.                         batchSize = N;  
37.                     } else {  
38.                         batchSize = mBatchSize;  
39.                     }  
40.   
41.                     ......  
42.   
43.                     Collections.sort(apps,  
44.                         new ResolveInfo.DisplayNameComparator(packageManager));  
45.                 }  
46.   
47.                 startIndex = i;  
48.                 for (int j=0; i<N && j<batchSize; j++) {  
49.                     // This builds the icon bitmaps.  
50.                     mAllAppsList.add(new ApplicationInfo(apps.get(i), mIconCache));  
51.                     i++;  
52.                 }  
53.   
54.                 final boolean first = i <= batchSize;  
55.                 final Callbacks callbacks = tryGetCallbacks(oldCallbacks);  
56.                 final ArrayList<ApplicationInfo> added = mAllAppsList.added;  
57.                 mAllAppsList.added = new ArrayList<ApplicationInfo>();  
58.               
59.                 mHandler.post(new Runnable() {  
60.                     public void run() {  
61.                         final long t = SystemClock.uptimeMillis();  
62.                         if (callbacks != null) {  
63.                             if (first) {  
64.                                 callbacks.bindAllApplications(added);  
65.                             } else {  
66.                                 callbacks.bindAppsAdded(added);  
67.                             }  
68.                             ......  
69.                         } else {  
70.                             ......  
71.                         }  
72.                     }  
73.                 });  
74.   
75.                 ......  
76.             }  
77.   
78.             ......  
79.         }  
80.   
81.         ......  
82.     }  
83.   
84.     ......  
85. }  

       我们先进入到PackageManagerService.queryIntentActivities函数中看看是如何获得这些Activity的，然后再回到这个函数中来看其余操作。

       这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

[java] view
plaincopy

1. class PackageManagerService extends IPackageManager.Stub {  
2.     ......  
3.   
4.     public List<ResolveInfo> queryIntentActivities(Intent intent,  
5.             String resolvedType, int flags) {  
6.         ......  
7.   
8.         synchronized (mPackages) {  
9.             String pkgName = intent.getPackage();  
10.             if (pkgName == null) { 
11. 
    
12. //启动PackageManagerService时，会把系统中的应用程序都解析一遍，然后把解析得到的Activity都保存在mActivities变量中, 这里通过这个mActivities变量的queryIntent函数返回符合条件intent的Activity，这里要返回的便是Action类型为Intent.ACTION_MAIN，并且Category类型为Intent.CATEGORY_LAUNCHER的Activity了
13.                 return (List<ResolveInfo>)mActivities.queryIntent(intent,  
14.                         resolvedType, flags);  
15.             }  
16.   
17.             ......  
18.         }  
19.   
20.         ......  
21.     }  
22.   
23.     ......  
24. }  

Step4、

        回到LoaderTask.loadAllAppsByBatch函数中，从queryIntentActivities函数调用处返回所要求的Activity后，便调用函数tryGetCallbacks(oldCallbacks)得到一个返CallBack接口，这个接口是由Launcher类实现的，接着调用这个接口的.bindAllApplications函数来进一步操作。注意，这里又是通过消息来处理加载应用程序的操作的。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/Launcher.java文件中：

[java] view
plaincopy

1. public final class Launcher extends Activity  
2.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
3.     ......  
4.   
5.     private AllAppsView mAllAppsGrid;  
6.   
7.     ......  
8.   
9.     public void bindAllApplications(ArrayList<ApplicationInfo> apps) {  
10.         mAllAppsGrid.setApps(apps);  
11.     }  
12.   
13.     ......  
14. }  

        这里的mAllAppsGrid是一个AllAppsView类型的变量，它的实际类型一般就是AllApps2D了。

        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/AllApps2D.java文件中：

[java] view
plaincopy

1. public class AllApps2D  
2.     extends RelativeLayout  
3.     implements AllAppsView,  
4.         AdapterView.OnItemClickListener,  
5.         AdapterView.OnItemLongClickListener,  
6.         View.OnKeyListener,  
7.         DragSource {  
8.   
9.     ......  
10.   
11.     public void setApps(ArrayList<ApplicationInfo> list) {  
12.         mAllAppsList.clear();  
13.         addApps(list);  
14.     }  
15.   
16.     public void addApps(ArrayList<ApplicationInfo> list) {  
17.         final int N = list.size();  
18.   
19.         for (int i=0; i<N; i++) {  
20.             final ApplicationInfo item = list.get(i);  
21.             int index = Collections.binarySearch(mAllAppsList, item,  
22.                 LauncherModel.APP_NAME_COMPARATOR);  
23.             if (index < 0) {  
24.                 index = -(index+1);  
25.             }  
26.             mAllAppsList.add(index, item);  
27.         }  
28.         mAppsAdapter.notifyDataSetChanged();  
29.     }  
30.   
31.     ......  
32. }  

        函数setApps首先清空mAllAppsList列表，然后调用addApps函数来为上一步得到的每一个应用程序创建一个ApplicationInfo实例了，有了这些ApplicationInfo实例之后，就可以在桌面上展示系统中所有的应用程序了。

        到了这里，系统默认的Home应用程序Launcher就把PackageManagerService中的应用程序加载进来了，当我们在屏幕上点击下面这个图标时，就会把刚才加载好的应用程序以图标的形式展示出来了：

        点击这个按钮时，便会响应Launcher.onClick函数：

[java] view
plaincopy

1. public final class Launcher extends Activity  
2.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
3.     ......  
4.   
5.     public void onClick(View v) {  
6.         Object tag = v.getTag();  
7.         if (tag instanceof ShortcutInfo) {  
8.             ......  
9.         } else if (tag instanceof FolderInfo) {  
10.             ......  
11.         } else if (v == mHandleView) {  
12.             if (isAllAppsVisible()) {  
13.                 ......  
14.             } else {  
15.                 showAllApps(true);  
16.             }  
17.         }  
18.     }  
19.   
20.     ......  
21. }  

        接着就会调用showAllApps函数显示应用程序图标：

[java] view
plaincopy

1. public final class Launcher extends Activity  
2.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
3.     ......  
4.   
5.     void showAllApps(boolean animated) {  
6.         mAllAppsGrid.zoom(1.0f, animated);  
7.   
8.         ((View) mAllAppsGrid).setFocusable(true);  
9.         ((View) mAllAppsGrid).requestFocus();  
10.   
11.         // TODO: fade these two too  
12.         mDeleteZone.setVisibility(View.GONE);  
13.     }  
14.   
15.     ......  
16. }  

        这样我们就可以看到系统中的应用程序了：

        当点击上面的这些应用程序图标时，便会响应AllApps2D.onItemClick函数：

[java] view
plaincopy

1. public class AllApps2D  
2.     extends RelativeLayout  
3.     implements AllAppsView,  
4.         AdapterView.OnItemClickListener,  
5.         AdapterView.OnItemLongClickListener,  
6.         View.OnKeyListener,  
7.         DragSource {  
8.   
9.     ......  
10.   
11.     public void onItemClick(AdapterView parent, View v, int position, long id) {  
12.         ApplicationInfo app = (ApplicationInfo) parent.getItemAtPosition(position);  
13.         mLauncher.startActivitySafely(app.intent, app);  
14.     }  
15.   
16.   
17.     ......  
18. }<span style="font-family:Arial, Verdana, sans-serif;"><span style="white-space: normal;">  
19. </span></span>  

        这里的成员变量mLauncher的类型为Launcher，于是就调用Launcher.startActivitySafely函数来启动应用程序了，这个过程具体可以参考Android应用程序启动过程源代码分析一文。