Android应用程序启动过程源代码分析（4）

Step 28. ActivityStack.realStartActivityLocked

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

1. public class ActivityStack {
3. ……
5. final boolean realStartActivityLocked(ActivityRecord r,
6. Proce***ecord app, boolean andResume, boolean checkConfig)
7. throws RemoteException {
9. ……
11. r.app = app;
13. ……
15. int idx = app.activities.indexOf(r);
16. if (idx < 0) {
17. app.activities.add(r);
18. }
20. ……
22. try {
23. ……
25. List<ResultInfo> results = null;
26. List<Intent> newIntents = null;
27. if (andResume) {
28. results = r.results;
29. newIntents = r.newIntents;
30. }
32. ……
34. app.thread.scheduleLaunchActivity(new Intent(r.intent), r,
35. System.identityHashCode(r),
36. r.info, r.icicle, results, newIntents, !andResume,
37. mService.isNextTransitionForward());
39. ……
41. } catch (RemoteException e) {
42. ……
43. }
45. ……
47. return true;
48. }
50. ……
52. }

这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值。

Step 29. ApplicationThreadProxy.scheduleLaunchActivity 这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

1. class ApplicationThreadProxy implements IApplicationThread {
3. ……
5. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
6. ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
7. List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)
8. throws RemoteException {
9. Parcel data = Parcel.obtain();
10. data.writeInterfaceToken(IApplicationThread.descriptor);
11. intent.writeToParcel(data, 0);
12. data.writeStrongBinder(token);
13. data.writeInt(ident);
14. info.writeToParcel(data, 0);
15. data.writeBundle(state);
16. data.writeTypedList(pendingResults);
17. data.writeTypedList(pendingNewIntents);
18. data.writeInt(notResumed ? 1 : 0);
19. data.writeInt(isForward ? 1 : 0);
20. mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
21. IBinder.FLAG_ONEWAY);
22. data.recycle();
23. }
25. ……
27. }

这个函数最终通过Binder驱动程序进入到ApplicationThread的scheduleLaunchActivity函数中。

Step 30. ApplicationThread.scheduleLaunchActivity 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
3. ……
5. private final class ApplicationThread extends ApplicationThreadNative {
7. ……
9. // we use token to identify this activity without having to send the
10. // activity itself back to the activity manager. (matters more with ipc)
11. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
12. ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
13. List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {
14. ActivityClientRecord r = new ActivityClientRecord();
16. r.token = token;
17. r.ident = ident;
18. r.intent = intent;
19. r.activityInfo = info;
20. r.state = state;
22. r.pendingResults = pendingResults;
23. r.pendingIntents = pendingNewIntents;
25. r.startsNotResumed = notResumed;
26. r.isForward = isForward;
28. queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
29. }
31. ……
33. }
35. ……
36. }

函数首先创建一个ActivityClientRecord实例，并且初始化它的成员变量，然后调用ActivityThread类的queueOrSendMessage函数进一步处理。

Step 31. ActivityThread.queueOrSendMessage 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
3. ……
5. private final class ApplicationThread extends ApplicationThreadNative {
7. ……
9. // if the thread hasn’t started yet, we don’t have the handler, so just
10. // save the messages until we’re ready.
11. private final void queueOrSendMessage(int what, Object obj) {
12. queueOrSendMessage(what, obj, 0, 0);
13. }
15. ……
17. private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
18. synchronized (this) {
19. ……
20. Message msg = Message.obtain();
21. msg.what = what;
22. msg.obj = obj;
23. msg.arg1 = arg1;
24. msg.arg2 = arg2;
25. mH.sendMessage(msg);
26. }
27. }
29. ……
31. }
33. ……
34. }

函数把消息内容放在msg中，然后通过mH把消息分发出去，这里的成员变量mH我们在前面已经见过，消息分发出去后，最后会调用H类的handleMessage函数。

Step 32. H.handleMessage

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
3. ……
5. private final class H extends Handler {
7. ……
9. public void handleMessage(Message msg) {
10. ……
11. switch (msg.what) {
12. case LAUNCH_ACTIVITY: {
13. ActivityClientRecord r = (ActivityClientRecord)msg.obj;
15. r.packageInfo = getPackageInfoNoCheck(
16. r.activityInfo.applicationInfo);
17. handleLaunchActivity(r, null);
18. } break;
19. ……
20. }
22. ……
24. }
26. ……
27. }

这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。

Step 33. ActivityThread.handleLaunchActivity

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
3. ……
5. private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
6. ……
8. Activity a = performLaunchActivity(r, customIntent);
10. if (a != null) {
11. r.createdConfig = new Configuration(mConfiguration);
12. Bundle oldState = r.state;
13. handleResumeActivity(r.token, false, r.isForward);
15. ……
16. } else {
17. ……
18. }
19. }
21. ……
22. }

这里首先调用performLaunchActivity函数来加载这个Activity类，即shy.luo.activity.MainActivity，然后调用它的onCreate函数，最后回到handleLaunchActivity函数时，再调用handleResumeActivity函数来使这个Activity进入Resumed状态，即会调用这个Activity的onResume函数，这是遵循Activity的生命周期的。

Step 34. ActivityThread.performLaunchActivity 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {
3. ……
5. private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
7. ActivityInfo aInfo = r.activityInfo;
8. if (r.packageInfo == null) {
9. r.packageInfo = getPackageInfo(aInfo.applicationInfo,
10. Context.CONTEXT_INCLUDE_CODE);
11. }
13. ComponentName component = r.intent.getComponent();
14. if (component == null) {
15. component = r.intent.resolveActivity(
16. mInitialApplication.getPackageManager());
17. r.intent.setComponent(component);
18. }
20. if (r.activityInfo.targetActivity != null) {
21. component = new ComponentName(r.activityInfo.packageName,
22. r.activityInfo.targetActivity);
23. }
25. Activity activity = null;
26. try {
27. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
28. activity = mInstrumentation.newActivity(
29. cl, component.getClassName(), r.intent);
30. r.intent.setExtrasClassLoader(cl);
31. if (r.state != null) {
32. r.state.setClassLoader(cl);
33. }
34. } catch (Exception e) {
35. ……
36. }
38. try {
39. Application app = r.packageInfo.makeApplication(false, mInstrumentation);
41. ……
43. if (activity != null) {
44. ContextImpl appContext = new ContextImpl();
45. appContext.init(r.packageInfo, r.token, this);
46. appContext.setOuterContext(activity);
47. CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
48. Configuration config = new Configuration(mConfiguration);
49. ……
50. activity.attach(appContext, this, getInstrumentation(), r.token,
51. r.ident, app, r.intent, r.activityInfo, title, r.parent,
52. r.embeddedID, r.lastNonConfigurationInstance,
53. r.lastNonConfigurationChildInstances, config);
55. if (customIntent != null) {
56. activity.mIntent = customIntent;
57. }
58. r.lastNonConfigurationInstance = null;
59. r.lastNonConfigurationChildInstances = null;
60. activity.mStartedActivity = false;
61. int theme = r.activityInfo.getThemeResource();
62. if (theme != 0) {
63. activity.setTheme(theme);
64. }
66. activity.mCalled = false;
67. mInstrumentation.callActivityOnCreate(activity, r.state);
68. ……
69. r.activity = activity;
70. r.stopped = true;
71. if (!r.activity.mFinished) {
72. activity.performStart();
73. r.stopped = false;
74. }
75. if (!r.activity.mFinished) {
76. if (r.state != null) {
77. mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
78. }
79. }
80. if (!r.activity.mFinished) {
81. activity.mCalled = false;
82. mInstrumentation.callActivityOnPostCreate(activity, r.state);
83. if (!activity.mCalled) {
84. throw new SuperNotCalledException(
85. “Activity “ + r.intent.getComponent().toShortString() +
86. ” did not call through to super.onPostCreate()”);
87. }
88. }
89. }
90. r.paused = true;
92. mActivities.put(r.token, r);
94. } catch (SuperNotCalledException e) {
95. ……
97. } catch (Exception e) {
98. ……
99. }
101. return activity;
102. }
104. ……
105. }

函数前面是收集要启动的Activity的相关信息，主要package和component信息：

1. ActivityInfo aInfo = r.activityInfo;
2. if (r.packageInfo == null) {
3. r.packageInfo = getPackageInfo(aInfo.applicationInfo,
4. Context.CONTEXT_INCLUDE_CODE);
5. }
7. ComponentName component = r.intent.getComponent();
8. if (component == null) {
9. component = r.intent.resolveActivity(
10. mInitialApplication.getPackageManager());
11. r.intent.setComponent(component);
12. }
14. if (r.activityInfo.targetActivity != null) {
15. component = new ComponentName(r.activityInfo.packageName,
16. r.activityInfo.targetActivity);
17. }

然后通过ClassLoader将shy.luo.activity.MainActivity类加载进来：

1. Activity activity = null;
2. try {
3. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
4. activity = mInstrumentation.newActivity(
5. cl, component.getClassName(), r.intent);
6. r.intent.setExtrasClassLoader(cl);
7. if (r.state != null) {
8. r.state.setClassLoader(cl);
9. }
10. } catch (Exception e) {
11. ……
12. }

接下来是创建Application对象，这是根据AndroidManifest.xml配置文件中的Application标签的信息来创建的：

1. Application app = r.packageInfo.makeApplication(false, mInstrumentation);

后面的代码主要创建Activity的上下文信息，并通过attach方法将这些上下文信息设置到MainActivity中去：

1. activity.attach(appContext, this, getInstrumentation(), r.token,
2. r.ident, app, r.intent, r.activityInfo, title, r.parent,
3. r.embeddedID, r.lastNonConfigurationInstance,
4. r.lastNonConfigurationChildInstances, config);

最后还要调用MainActivity的onCreate函数：

1. mInstrumentation.callActivityOnCreate(activity, r.state);

这里不是直接调用MainActivity的onCreate函数，而是通过mInstrumentation的callActivityOnCreate函数来间接调用，前面我们说过，mInstrumentation在这里的作用是监控Activity与系统的交互操作，相当于是系统运行日志。

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/110569.html原文链接：https://javaforall.cn