2023年12月24日发(作者：)
在前面一篇文章中，我们分析了Android系统在启动时安装应用程序的过程，这些应用程序安装好之后，还需要有一个Home应用程序来负责把它们在桌面上展示出来，在Android系统中，这个默认的Home应用程序就是Launcher了，本文将详细分析Launcher应用程序的启动过程。
Android系统的Home应用程序Launcher是由ActivityManagerService启动的，而ActivityManagerService和PackageManagerService一样，都是在开机时由SystemServer组件启动的，SystemServer组件首先是启动ePackageManagerServic，由它来负责安装系统的应用程序，具体可以参考前面一篇文章Android应用程序安装过程源代码分析，系统中的应用程序安装好了以后，SystemServer组件接下来就要通过ActivityManagerService来启动Home应用程序Launcher了，Launcher在启动的时候便会通过PackageManagerServic把系统中已经安装好的应用程序以快捷图标的形式展示在桌面上，这样用户就可以使用这些应用程序了，整个过程如下图所示：
点击查看大图
下面详细分析每一个步骤。
Step 1.
这个函数定义在frameworks/base/services/java/com/android/server/文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 1。
Step 2. 1
这个函数是一个JNI方法，实现在 frameworks/base/services/jni/com_android_server_文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 2。
Step 3. libsystem__init
函数system_init实现在libsystem_server库中，源代码位于frameworks/base/cmds/system_server/library/system_文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 3。
Step 4. atic
这个函数定义在frameworks/base/core/jni/文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 4。
Step 5. 2
这个函数定义在frameworks/base/services/java/com/android/server/文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 5。
Step 6.
这个函数定义在frameworks/base/services/java/com/android/server/文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 6。
Step 7.
这个函数定义在frameworks/base/services/java/com/android/server/am/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public final class ActivityManagerService extends ActivityManagerNative
implements r, yCallback {
......
public static final Context main(int factoryTest) {
AThread thr = new AThread();
();
synchronized (thr) {
10. while (ce == null) {
11. try {
12. ();
13. } catch (InterruptedException e) {
14. }
15. }
16. }
17.
18. ActivityManagerService m = ce;
19. mSelf = m;
20. ActivityThread at = Main();
21. mSystemThread = at;
22. Context context = temContext();
23. xt = context;
24. ryTest = factoryTest;
25. tack = new ActivityStack(m, context, true);
26.
27. h(context);
28. h(context);
29.
30. synchronized (thr) {
31. = true;
32. All();
33. }
34.
35. unning(null, null, null, null);
36.
37. return context;
38. }
39.
40. ......
41. }
这个函数首先通过AThread线程对象来内部创建了一个ActivityManagerService实例，然后将这个实例保存其成员变量mService中，接着又把这个ActivityManagerService实例保存在ActivityManagerService类的静态成员变量mSelf中，最后初始化其它成员变量，就结束了。
Step 8.
这个函数定义在frameworks/base/services/java/com/android/server/文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 7。执行完这一步之后，系统中的应用程序的所有信息都保存在PackageManagerService中了，后面Home应用程序Launcher启动起来后，就会把PackageManagerService中的应用程序信息取出来，然后以快捷图标的形式展示在桌面上，后面我们将会看到这个过程。
Step 9. temProcess
这个函数定义在frameworks/base/services/java/com/android/server/am/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
public final class ActivityManagerService extends ActivityManagerNative
implements r, yCallback {
......
public static void setSystemProcess() {
try {
ActivityManagerService m = mSelf;
8.
9.
vice("activity", m);
10. vice("meminfo", new MemBinder(m));
11. if (MONITOR_CPU_USAGE) {
12. vice("cpuinfo", new CpuBinder(m));
13. }
14. vice("permission", new PermissionController(m));
15.
16. ApplicationInfo info =
17. kageManager().getApplicationInfo(
18. "android", STOCK_PM_FLAGS);
19. lSystemApplicationInfo(info);
20.
21. synchronized (mSelf) {
22. ProcessRecord app = cessRecordLocked(
23. licationThread(), info,
24. sName);
25. tent = true;
26. = MY_PID;
27. = SYSTEM_ADJ;
28. (sName, , app);
29. synchronized (elfLocked) {
30. (, app);
31. }
32. LruProcessLocked(app, true, true);
33. }
34. } catch (tFoundException e) {
35. throw new RuntimeException(
36. "Unable to find android system package", e);
37. }
38. }
39. ......
40. }
这个函数首先是将这个ActivityManagerService实例添加到ServiceManager中去托管，这样其它地方就可以通过vice接口来访问这个全局唯一的ActivityManagerService实例了，接着又通过调用lSystemApplicationInfo函数来把应用程序框架层下面的android包加载进来 ，这里的mSystemThread是一个ActivityThread类型的实例变量，它是在上面的Step 7中创建的，后面就是一些其它的初始化工作了。
Step 10. Ready
这个函数是在上面的Step 6中的函数在将系统中的一系列服务都初始化完毕之后才调用的，它定义在frameworks/base/services/java/com/android/server/am/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public final class ActivityManagerService extends ActivityManagerNative
implements r, yCallback {
......
public void systemReady(final Runnable goingCallback) {
......
synchronized (this) {
......
10.
11. TopActivityLocked(null);
12. }
13. }
14.
15. ......
16. }
这个函数的内容比较多，这里省去无关的部分，主要关心启动Home应用程序的逻辑，这里就是通过TopActivityLocked函数来启动Home应用程序的了，这里的mMainStack是一个ActivityStack类型的实例变量。
Step 11. TopActivityLocked
这个函数定义在frameworks/base/services/java/com/android/server/am/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public class ActivityStack {
......
final boolean resumeTopActivityLocked(ActivityRecord prev) {
// Find the first activity that is not finishing.
ActivityRecord next = topRunningActivityLocked(null);
......
10. if (next == null) {
11. // There are no more activities! Let's just start up the
12. //
13. if (mMainStack) {
14. return omeActivityLocked();
15. }
16. }
17.
18. ......
19. }
20.
21. ......
22. }
这里调用函数topRunningActivityLocked返回的是当前系统Activity堆栈最顶端的Activity，由于此时还没有Activity被启动过，因此，返回值为null，即next变量的值为null，于是就调用omeActivityLocked语句，这里的mService就是前面在Step 7中创建的ActivityManagerService实例了。
Step 12. omeActivityLocked
这个函数定义在frameworks/base/services/java/com/android/server/am/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public final class ActivityManagerService extends ActivityManagerNative
implements r, yCallback {
......
boolean startHomeActivityLocked() {
......
Intent intent = new Intent(
mTopAction,
10. mTopData != null ? (mTopData) : null);
11. ponent(mTopComponent);
12. if (mFactoryTest != Y_TEST_LOW_LEVEL) {
13. egory(RY_HOME);
14. }
15. ActivityInfo aInfo =
16. eActivityInfo(kageManager(),
17. STOCK_PM_FLAGS);
18. if (aInfo != null) {
19. ponent(new ComponentName(
20. eName, ));
21. // Don't do this if the home app is currently being
22. // instrumented.
23. ProcessRecord app = getProcessRecordLocked(sName,
24. );
25. if (app == null || mentationClass == null) {
26. gs(gs() | _ACTIVITY_NEW_TASK);
27. ctivityLocked(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，然后通过eActivityInfo函数向PackageManagerService查询Category类型为HOME的Activity，这里我们假设只有系统自带的Launcher应用程序注册了HOME类型的Activity（见packages/apps/Launcher2/文件）：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
xmlns:android="/apk/res/android" package="er" android:sharedUserId="@string/sharedUserId" > ...... 10. android:name="erApplication" 11. android:process="@string/process" 12. android:label="@string/application_name" 13. android:icon="@drawable/ic_launcher_home"> 14. 15. 16. android:name="er" 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. 24. 25. 26. 27. 28. 29. 30. 31. ...... 32. 33.
因此，这里就返回er这个Activity了。由于是第一次启动这个Activity，接下来调用函数getProcessRecordLocked返回来的ProcessRecord值为null，于是，就调用ctivityLocked函数启动er这个Activity了，这里的mMainStack是一个ActivityStack类型的成员变量。
Step 13. ctivityLocked
这个函数定义在frameworks/base/services/java/com/android/server/am/文件中，具体可以参考Android应用程序启动过程源代码分析一文，这里就不详述了，在我们这个场景中，调用这个函数的最后结果就是把er启动起来，接着调用它的onCreate函数。
Step 14. te
这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中：
view plain
1.
2.
public final class Launcher extends Activity
implements kListener, OnLongClickListener, cks, r {
3.
4.
5.
6.
7.
8.
9.
......
@Override
protected void onCreate(Bundle savedInstanceState) {
......
if (!mRestoring) {
10. oader(this, true);
11. }
12.
13. ......
14. }
15.
16. ......
17. }
这里的mModel是一个LauncherModel类型的成员变量，这里通过调用它的startLoader成员函数来执行加应用程序的操作。
Step 15. oader
这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中：
view plain
1.
2.
3.
4.
5.
6.
public class LauncherModel extends BroadcastReceiver {
......
public void startLoader(Context context, boolean isLaunching) {
......
7.
8.
9.
synchronized (mLock) {
......
10. // Don't bother to start the thread if we know it's not going to do anything
11. if (mCallbacks != null && () != null) {
12. // If there is already one running, tell it to stop.
13. LoaderTask oldTask = mLoaderTask;
14. if (oldTask != null) {
15. if (ching()) {
16. // don't downgrade isLaunching if we're already running
17. isLaunching = true;
18. }
19. cked();
20. }
21. mLoaderTask = new LoaderTask(context, isLaunching);
22. (mLoaderTask);
23. }
24. }
25. }
26.
27. ......
28. }
这里不是直接加载应用程序，而是把加载应用程序的操作作为一个消息来处理。这里的sWorker是一个Handler，通过它的post方式把一个消息放在消息队列中去，然后系统就会调用传进去的参数mLoaderTask的run函数来处理这个消息，这个mLoaderTask是LoaderTask类型的实例，于是，下面就会执行LoaderTask类的run函数了。
Step 16.
这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public class LauncherModel extends BroadcastReceiver {
......
private class LoaderTask implements Runnable {
......
public void run() {
......
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成员函数来进一步操作。
Step 17. dBindAllApps
这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public class LauncherModel extends BroadcastReceiver {
......
private class LoaderTask implements Runnable {
......
private void loadAndBindAllApps() {
......
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函数来进一步操作了。
Step 18. lAppsByBatch
这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中：
view plain
1.
2.
3.
4.
5.
6.
7.
8.
9.
public class LauncherModel extends BroadcastReceiver {
......
private class LoaderTask implements Runnable {
......
private void loadAllAppsByBatch() {
......
10. final Intent mainIntent = new Intent(_MAIN, null);
11. egory(RY_LAUNCHER);
12.
13. final PackageManager packageManager = kageManager();
14. List
15.
16. int N = _VALUE;
17.
18. int startIndex;
19. int i=0;
20. int batchSize = -1;
21. while (i < N && !mStopped) {
22. if (i == 0) {
23. ();
24. ......
25. apps = ntentActivities(mainIntent, 0);
26.
27. ......
28.
29. N = ();
30.
31. ......
32.
33. if (mBatchSize == 0) {
34. batchSize = N;
35. } else {
36. batchSize = mBatchSize;
37. }
38.
39. ......
40.
41. (apps,
42. new yNameComparator(packageManager));
43. }
44.
45. startIndex = i;
46. for (int j=0; i 47. // This builds the icon bitmaps. 48. (new ApplicationInfo((i), mIconCache)); 49. i++; 50. } 51. 52. final boolean first = i <= batchSize; 53. final Callbacks callbacks = tryGetCallbacks(oldCallbacks); 54. final ArrayList 55. = new ArrayList 56. 57. (new Runnable() { 58. public void run() { 59. final long t = Millis(); 60. if (callbacks != null) { 61. if (first) { 62. lApplications(added); 63. } else { 64. psAdded(added); 65. } 66. ...... 67. } else { 68. ...... 69. } 70. } 71. }); 72. 73. ...... 74. } 75. 76. ...... 77. } 78. 79. ...... 80. } 81. 82. ...... 83. } 函数首先构造一个CATEGORY_LAUNCHER类型的Intent： view plain 1. 2. final Intent mainIntent = new Intent(_MAIN, null); egory(RY_LAUNCHER); 接着从mContext变量中获得PackageManagerService的接口： view plain 1. final PackageManager packageManager = kageManager(); 下一步就是通过这个ntentActivities接口来取回所有Action类型为_MAIN，并且Category类型为RY_LAUNCHER的Activity了。 我们先进入到ntentActivities函数中看看是如何获得这些Activity的，然后再回到这个函数中来看其余操作。 Step 19. ntentActivities 这个函数定义在frameworks/base/services/java/com/android/server/文件中： view plain 1. 2. 3. 4. 5. 6. 7. 8. 9. class PackageManagerService extends { ...... public List String resolvedType, int flags) { ...... synchronized (mPackages) { String pkgName = kage(); 10. if (pkgName == null) { 11. return (List 12. resolvedType, flags); 13. } 14. 15. ...... 16. } 17. 18. ...... 19. } 20. 21. ...... 22. } 回忆前面一篇文章Android应用程序安装过程源代码分析，系统在前面的Step 8中启动PackageManagerService时，会把系统中的应用程序都解析一遍，然后把解析得到的Activity都保存在mActivities变量中，这里通过这个mActivities变量的queryIntent函数返回符合条件intent的Activity，这里要返回的便是Action类型为_MAIN，并且Category类型为RY_LAUNCHER的Activity了。 回到Step 18中的 lAppsByBatch函数中，从queryIntentActivities函数调用处返回所要求的Activity后，便调用函数tryGetCallbacks(oldCallbacks)得到一个返CallBack接口，这个接口是由Launcher类实现的，接着调用这个接口的.bindAllApplications函数来进一步操作。注意，这里又是通过消息来处理加载应用程序的操作的。 Step 20. lApplications 这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中： view plain 1. 2. public final class Launcher extends Activity implements kListener, OnLongClickListener, cks, r { 3. 4. 5. 6. 7. 8. 9. ...... private AllAppsView mAllAppsGrid; ...... public void bindAllApplications(ArrayList 10. s(apps); 11. } 12. 13. ...... 14. } 这里的mAllAppsGrid是一个AllAppsView类型的变量，它的实际类型一般就是AllApps2D了。 Step 21. s 这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/文件中： view plain 1. 2. 3. 4. 5. 6. 7. 8. 9. public class AllApps2D extends RelativeLayout implements AllAppsView, ClickListener, LongClickListener, istener, DragSource { ...... 10. 11. public void setApps(ArrayList 12. (); 13. addApps(list); 14. } 15. 16. public void addApps(ArrayList 17. final int N = (); 18. 19. for (int i=0; i 20. final ApplicationInfo item = (i); 21. int index = Search(mAllAppsList, item, 22. _NAME_COMPARATOR); 23. if (index < 0) { 24. index = -(index+1); 25. } 26. (index, item); 27. } 28. DataSetChanged(); 29. } 30. 31. ...... 32. } 函数setApps首先清空mAllAppsList列表，然后调用addApps函数来为上一步得到的每一个应用程序创建一个ApplicationInfo实例了，有了这些ApplicationInfo实例之后，就可以在桌面上展示系统中所有的应用程序了。 到了这里，系统默认的Home应用程序Launcher就把PackageManagerService中的应用程序加载进来了，当我们在屏幕上点击下面这个图标时，就会把刚才加载好的应用程序以图标的形式展示出来了： 点击这个按钮时，便会响应k函数： view plain 1. 2. public final class Launcher extends Activity implements kListener, OnLongClickListener, cks, r { 3. 4. 5. 6. 7. 8. 9. ...... public void onClick(View v) { Object tag = (); if (tag instanceof ShortcutInfo) { ...... } 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函数显示应用程序图标： view plain 1. 2. public final class Launcher extends Activity implements kListener, OnLongClickListener, cks, r { 3. 4. 5. 6. 7. 8. 9. ...... void showAllApps(boolean animated) { (1.0f, animated); ((View) mAllAppsGrid).setFocusable(true); ((View) mAllAppsGrid).requestFocus(); 10. 11. // TODO: fade these two too 12. ibility(); 13. } 14. 15. ...... 16. } 这样我们就可以看到系统中的应用程序了： 当点击上面的这些应用程序图标时，便会响应Click函数： view plain 1. 2. 3. 4. 5. 6. 7. 8. 9. public class AllApps2D extends RelativeLayout implements AllAppsView, ClickListener, LongClickListener, istener, DragSource { ...... 10. 11. public void onItemClick(AdapterView parent, View v, int position, long id) { 12. ApplicationInfo app = (ApplicationInfo) mAtPosition(position); 13. ctivitySafely(, app); 14. } 15. 16. 17. ...... 18. } 这里的成员变量mLauncher的类型为Launcher，于是就调用ctivitySafely函数来启动应用程序了，这个过程具体可以参考Android应用程序启动过程源代码分析一文。
发布评论