本文分析的源代码基于 android27
Activity的启动流程相当复杂，比如我们在Activity A 打开Activity B。这一过程开始于A.startActivity 经过 Android System 的处理，最终调用 B 的生命周期方法结束。
上面的过程具体描述的话太过于复杂，我们可以将其拆解成3部分依次突破。
startActivity --> ActivityManagerService
ActivityManagerService --> ApplicationThread
ApplicationThread --> Activity
(一) startActivity --> ActivityManagerService
ActivityManagerService后续简称 AMS。先放一张时序图:
从Activity的startActivity方法到AMS中间的过程并不复杂，下面看下源码中做了哪些操作：
Activity的startActivity
1@Override
2public void startActivity(Intent intent, @Nullable Bundle options) {
3 if (options != null) {
4 //第二个参数为-1，表示不需要知道Activity启动的结果
5 startActivityForResult(intent, -1, options);
6 } else {
7 startActivityForResult(intent, -1);
8}
startActivity中调用startActivityForResult
Activity的startActivityForResult
1public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
2 if (mParent == null) {//mParent表示当前Activity的父类，一般为null
3 options = transferSpringboardActivityOptions(options);
4
5 //调用Instrumentation.execStartActivity()，启动新的Activity。
6 //mMainThread类型为ActivityThread, 在attach()时被回调时被赋值。
7 Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options);
8 if (ar != null) {
9 mMainThread.sendActivityResult(
10 mToken, mEmbeddedID, requestCode, ar.getResultCode(),
11 ar.getResultData());
12 }
13 if (requestCode >= 0) {
14 mStartedActivity = true;
15 }
16
17 cancelInputsAndStartExitTransition(options);
18 } else {
19 ...
20 }
21}
startActivityForResult也很简单，调用Instrumentation.execStartActivity方法。剩下的交给Instrumentation类去处理。
Instrumentation类主要用来监控应用程序与系统交互
红色字体标明的mMainThread是ActivityThread类型，ActivityThread可以理解为一个进程，在这就是A所在的进程
通过mMainThread获取一个ApplicationThread的引用，这个引用就是用来实现进程间通信的，具体来说就 AMS 所在的系统进程通知应用程序进程进行一系列操作，后面会用到
Instrumentation的execStartActivity
1public ActivityResult execStartActivity(
2 Context who, IBinder contextThread, IBinder token, Activity target,
3 Intent intent, int requestCode, Bundle options) {
4
5 //将contextThread转成ApplicationThread.
6 IApplicationThread whoThread = (IApplicationThread) contextThread;
7 /*
8 * 中间代码省略
9 */
10 try {
11 intent.migrateExtraStreamToClipData();
12 intent.prepareToLeaveProcess(who);
13 //实际上这里是通过AIDL来调用AMS的startActivity方法，下面我们看下ActivityManager.getService()的代码
14 int result = ActivityManager.getService()
15 .startActivity(whoThread, who.getBasePackageName(), intent,
16 intent.resolveTypeIfNeeded(who.getContentResolver()),
17 token, target != null ? target.mEmbeddedID : null,
18 requestCode, 0, null, options);
19 checkStartActivityResult(result, intent);//检查StartActivity的结果
20 } catch (RemoteException e) {
21 throw new RuntimeException("Failure from system", e);
22 }
23 return null;
24}
熟悉Android Binder机制的同学应该很快就能定位到此处实际调用到了ActivityManagerService的startActivity方法。接下来的工作重心就由A进程转移到了AMS所在的系统进程。
(二) AMS --> ApplicationThread
接下来就看下在AMS中是如何一步一步执行到B进程的。这里先剧透一下: 刚才在看Instrumentation的时候，我们讲过一个ApplicationThread类，这个类是实现进程间通信的，这里AMS最终其实就是调用了B进程中的一个ApplicationThread引用，从而间接的通知B进程进行相应操作。
还是线上时序图：
相比于startActivity-->AMS，AMS-->ApplicationThread流程看起来复杂好多了，实际上这里面就干了2件事
1 综合处理launchMode和Intent中的Flag标志位，并根据处理结果生成一个目标Activity B的对象(ActivityRecord)
2 判断是否需要为目标Activity B创建一个新的进程(ProcessRecord)、新的任务栈(TaskRecord)3 来来回回的操作AMS或者ActivityStackSupervisor中的那几个比较核心的数据结构
接下来就从AMS的startActivity方法开始看起：
AMS的startActivity
1@Override
2 public final int startActivity(IApplicationThread caller, String callingPackage,
3 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4 int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
5 return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
6 resultWho, requestCode, startFlags, profilerInfo, bOptions,
7 UserHandle.getCallingUserId());
8}
很简单就是调用了startActivityAsUser
AMS的startActivityAsUser
1@Override
2 public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
3 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
4 int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
5 enforceNotIsolatedCaller("startActivity");//检查调用者是否合法
6 userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
7 userId, false, ALLOW_FULL_ONLY, "startActivity", null);)//检查调用者是否有权限执行操作
8
9 return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
10 resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
11 profilerInfo, null, null, bOptions, false, userId, null, "startActivityAsUser");
12}
这个方法实际上就是检查当前用户是否有权限。然后就将所有的工作交给了一个叫做ActivityStarter的类中。
ActivityStarter的startActivityMayWait
ActivityStarter这个类看名字就知道它专门负责一个Activity的启动操作。它的主要作用包括解析Intent、创建ActivityRecord、如果有可能还要创建TaskRecord。其中的实现细节可以暂时跳过，总之经过一顿猛如虎的操作之后代码会被调用到startActivityUnchecked()
1private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
2 IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
3 int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {
4 setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
5 voiceInteractor);//1
6 computeLaunchingTaskFlags();//2
7 computeSourceStack();
8 mIntent.setFlags(mLaunchFlags);//3
9
10 ...
11
12 mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
13}
注释1处用于初始化启动Activity的各种配置，在初始化前会重置各种配置再进行配置，这些配置包括：ActivityRecord、Intent、TaskRecord和LaunchFlags（启动的FLAG）等等。注释2处的computeLaunchingTaskFlags方法用于计算出启动的FLAG，并将计算的值赋值给mLaunchFlags。在注释3处将mLaunchFlags设置给Intent，达到设定Activity的启动方式的目的。接着来查看computeLaunchingTaskFlags方法。
ActivityStarter的computeLaunchingTaskFlags
1private void computeLaunchingTaskFlags() {
2...
3 if (mInTask == null) {//1
4 if (mSourceRecord == null) {//2
5 if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {//3
6 Slog.w(TAG, "startActivity called from non-Activity context; forcing " +
7 "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
8 mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
9 }
10 } else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {//4
11 mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
12 } else if (mLaunchSingleInstance || mLaunchSingleTask) {//5
13 mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
14 }
15 }
16}
计算启动的FLAG的逻辑比较复杂，这里只截取了一小部分，注释1处的TaskRecord类型的mInTask为null时，说明Activity要加入的栈不存在。因此，这一小段代码主要解决的问题就是Activity要加入的栈不存在时如何计算出启动的FLAG。注释2处，ActivityRecord类型的mSourceRecord用于描述“初始Activity”，什么是“初始Activity”呢？比如ActivityA启动了ActivityB，ActivityA就是初始Activity。同时满足注释2和注释3的条件则需要创建一个新栈。注释4处，如果“初始Activity”所在的栈只允许有一个Activity实例，则也需要创建一个新栈。注释5处，如果Launch Mode设置了singleTask或singleInstance，则也要创建一个新栈。
在ActivityStarter -> startActivityUnchecked方法中，最终调用了mSupervisor的resumeFocusedStackTopActivityLocked方法。这个mSupervisor是ActivityStackSupervisor类型，简单来说它是ActivityStack的管理类。
ActivityStackSupervisor的resumeFocusedStackTopActivityLocked
1 boolean resumeFocusedStackTopActivityLocked(
2 ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
3
4 //...
5
6 if (targetStack != null && isFocusedStack(targetStack)) {
7 return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
8
9 //...
10}
继续往下看
ActivityStack的resumeTopActivityUncheckedLocked
1boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
2 if (mStackSupervisor.inResumeTopActivity) {
3 // Don't even start recursing.
4 return false;
5 }
6
7 boolean result = false;
8 try {
9 // Protect against recursion.
10 mStackSupervisor.inResumeTopActivity = true;
11 result = resumeTopActivityInnerLocked(prev, options);
12 } finally {
13 mStackSupervisor.inResumeTopActivity = false;
14 }
15
16 //...
17 return result;
18}
继续调用resumeTopActivityInnerLocked方法
ActivityStack的resumeTopActivityInnerLocked
1private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
2
3 //...
4 if (mResumedActivity != null) {
5 if (DEBUG_STATES) Slog.d(TAG_STATES,
6 "resumeTopActivityLocked: Pausing " + mResumedActivity);
7
8 //暂停当前activity，调用Activity的onPause
9 pausing |= startPausingLocked(userLeaving, false, next, false);
10 }
11 //...
12 mStackSupervisor.startSpecificActivityLocked(next, true, true);//启动新activity
13 //...
14}
这个方法虽然是叫resume..., 但是在这之前需要先调用startPausingLocked方法将之前的A给暂停，因此在A中调用startActivity打开B时，实际上是先执行A的onPause方法，在执行B的onCreate生命周期。
最后代码又回到了ActivityStackSupervisor
ActivityStackSupervisor的startSpecificActivityLocked
1void startSpecificActivityLocked(ActivityRecord r,boolean andResume, boolean checkConfig) {
2
3 ProcessRecord app = mService.getProcessRecordLocked(r.processName,
4 r.info.applicationInfo.uid, true);//获取ProcessRecord
5
6 r.getStack().setLaunchTime(r);
7
8 if (app != null && app.thread != null) {
9 try {
10 if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
11 || !"android".equals(r.info.packageName)) {
12
13 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
14 mService.mProcessStats);
15 }
16 realStartActivityLocked(r, app, andResume, checkConfig);
17 return;
18 } catch (RemoteException e) {
19 Slog.w(TAG, "Exception when starting activity "
20 + r.intent.getComponent().flattenToShortString(), e);
21 }
22 }
23
24 //创建新的ProcessRecord
25 mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
26 "activity", r.intent.getComponent(), false, false, true);
27}
这个方法中，判断系统Activity B进程(ProcessRecord)是否正在运行, 如果是则继续执行realStartActivityLocked方法，否则会调用AMS的startProcessLocked方法创建进程。
ActivityStackSupervisor的realStartActivityLocked
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
//...
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
//...
} 简单介绍一下这行代码:
app是ProcessRecord类型，代表一个进程记录，在这就是B进程。
app.thread是ApplicationThread类型，上面已经介绍过了，通过它实现进程间通信
上面的app.thread.scheduleLaunchActivity这行代码的意思就是通知B进程中的ApplicationThread执行scheduleLaunchActivity方法，至此工作重心就离开系统AMS进程，剩下的事情全部都是在B进程中执行了。
代码看到这里大脑细胞很可能已经不够用了，因此一下子涌出了好几个类：ActivityStarter、ActivityStackSupervisor、ActivityStack、TaskRecord、ActivityRecord。 接下来我们再理一下这几个类之间的关系。
先来张简单的关系图：
一个ActivityRecord对应一个Activity，保存了一个Activity的所有信息; 但是一个Activity可能会有多个ActivityRecord,因为Activity可以被多次启动，这个主要取决于其启动模式。
一个TaskRecord由一个或者多个ActivityRecord组成，这就是我们常说的任务栈，具有后进先出的特点。
ActivityStack则是用来管理TaskRecord的，包含了多个TaskRecord。
ActivityRecord
ActivityRecord，源码中的注释介绍：An entry in the history stack, representing an activity.
翻译：历史栈中的一个条目，代表一个activity。
frameworks/base/services/core/java/com/android/server/am/ActivityRecord.java
final class ActivityRecord extends ConfigurationContainer implements AppWindowContainerListener {
final ActivityManagerService service; // owner
final IApplicationToken.Stub appToken; // window manager token
AppWindowContainerController mWindowContainerController;
final ActivityInfo info; // all about me
final ApplicationInfo appInfo; // information about activity's app
//省略其他成员变量
//ActivityRecord所在的TaskRecord
private TaskRecord task; // the task this is in.
//构造方法，需要传递大量信息
ActivityRecord(ActivityManagerService _service, ProcessRecord _caller, int _launchedFromPid,
int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
ActivityInfo aInfo, Configuration _configuration,
com.android.server.am.ActivityRecord _resultTo, String _resultWho, int _reqCode,
boolean _componentSpecified, boolean _rootVoiceInteraction,
ActivityStackSupervisor supervisor, ActivityOptions options,
com.android.server.am.ActivityRecord sourceRecord) {
}
}实际上，
ActivityRecord中存在着大量的成员变量，包含了一个Activity的所有信息。ActivityRecord中的成员变量task表示其所在的TaskRecord，由此可以看出：ActivityRecord与TaskRecord建立了联系。
startActivity()时会创建一个ActivityRecord：
class ActivityStarter {
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
com.android.server.am.ActivityRecord[] outActivity, TaskRecord inTask) {
//其他代码略
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, options, sourceRecord);
//其他代码略
}
}TaskRecord
TaskRecord，内部维护一个ArrayList<ActivityRecord>用来保存ActivityRecord。
final class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
final int taskId; //任务ID
final ArrayList<ActivityRecord> mActivities; //使用一个ArrayList来保存所有的ActivityRecord
private ActivityStack mStack; //TaskRecord所在的ActivityStack
//构造方法
TaskRecord(ActivityManagerService service, int _taskId, ActivityInfo info, Intent _intent,
IVoiceInteractionSession _voiceSession, IVoiceInteractor _voiceInteractor, int type) {
}
//添加Activity到顶部
void addActivityToTop(com.android.server.am.ActivityRecord r) {
addActivityAtIndex(mActivities.size(), r);
}
//添加Activity到指定的索引位置
void addActivityAtIndex(int index, ActivityRecord r) {
//...
r.setTask(this);//为ActivityRecord设置TaskRecord，就是这里建立的联系
//...
index = Math.min(size, index);
mActivities.add(index, r);//添加到mActivities
//...
}
//其他代码略
}可以看到
TaskRecord中使用了一个ArrayList来保存所有的ActivityRecord。同样，
TaskRecord中的mStack表示其所在的ActivityStack。
startActivity()时也会创建一个TaskRecord：
class ActivityStarter {
private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate, int preferredLaunchStackId, ActivityStack topStack) {
mTargetStack = computeStackFocus(mStartActivity, true, mLaunchBounds, mLaunchFlags, mOptions);
if (mReuseTask == null) {
//创建一个createTaskRecord，实际上是调用ActivityStack里面的createTaskRecord（）方法，ActivityStack下面会讲到
final TaskRecord task = mTargetStack.createTaskRecord(
mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity.mActivityType);
//其他代码略
}
}
}ActivityStack
ActivityStack,内部维护了一个ArrayList<TaskRecord>，用来管理TaskRecord。
class ActivityStack<T extends StackWindowController> extends ConfigurationContainer implements StackWindowListener {
private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();//使用一个ArrayList来保存TaskRecord
final int mStackId;
protected final ActivityStackSupervisor mStackSupervisor;//持有一个ActivityStackSupervisor，所有的运行中的ActivityStacks都通过它来进行管理
//构造方法
ActivityStack(ActivityStackSupervisor.ActivityDisplay display, int stackId,
ActivityStackSupervisor supervisor, RecentTasks recentTasks, boolean onTop) {
}
TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
boolean toTop, int type) {
//创建一个task
TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession, voiceInteractor, type);
//将task添加到ActivityStack中去
addTask(task, toTop, "createTaskRecord");
//其他代码略
return task;
}
//添加Task
void addTask(final TaskRecord task, final boolean toTop, String reason) {
addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);
//其他代码略
}
//添加Task到指定位置
void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
String reason) {
mTaskHistory.remove(task);//若存在，先移除
//...
mTaskHistory.add(position, task);//添加task到mTaskHistory
task.setStack(this);//为TaskRecord设置ActivityStack
//...
}
//其他代码略
}可以看到
ActivityStack使用了一个ArrayList来保存TaskRecord。另外，
ActivityStack中还持有ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。
ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的，继续看下面的ActivityStackSupervisor分析。
ActivityStackSupervisor
ActivityStackSupervisor，顾名思义，就是用来管理ActivityStack的。
public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {
ActivityStack mHomeStack;//管理的是Launcher相关的任务
ActivityStack mFocusedStack;//管理非Launcher相关的任务
//创建ActivityStack
ActivityStack createStack(int stackId, ActivityStackSupervisor.ActivityDisplay display, boolean onTop) {
switch (stackId) {
case PINNED_STACK_ID:
//PinnedActivityStack是ActivityStack的子类
return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
default:
//创建一个ActivityStack
return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
}
}
}ActivityStackSupervisor内部有两个不同的ActivityStack对象：mHomeStack、mFocusedStack，用来管理不同的任务。ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。
AMS初始化时会创建一个ActivityStackSupervisor对象。
1public ActivityManagerService(){
2 mStackSupervisor = createStackSupervisor();
3}
4
5protected ActivityStackSupervisor createStackSupervisor() {
6 return new ActivityStackSupervisor(this, mHandler.getLooper());
7}
总结
所以，实际上，他们的关系应该是这样的：
(三) ApplicationThread --> Activity
同样还是先来一张时序图：
从ApplicationThread到真正启动一个Activity，其实也并不是很复杂。
ApplicationThread的scheduleLaunchActivity
ApplicationThread是ActivityThread的内部类。
scheduleLaunchActivity中就是将启动Activity的参数封装成ActivityClientRecord，然后调用ActivityThread的sendMessage方法。
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.referrer = referrer;
r.voiceInteractor = voiceInteractor;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.persistentState = persistentState;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profilerInfo = profilerInfo;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
//调用ActivityThread的sendMessage方法，发送LAUNCH_ACTIVITY信息
sendMessage(H.LAUNCH_ACTIVITY, r);
}ApplicationThread的sendMessage
private void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) Slog.v(
TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
+ ": " + arg1 + " / " + obj);
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}H是ActivityThread的一个内部类
private class H extends Handler { //继承Handler
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {//启动ACTIVITY
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case RELAUNCH_ACTIVITY: {
//...
} break;
case PAUSE_ACTIVITY: {
//...
} break;
case PAUSE_ACTIVITY_FINISHING: {
//...
} break;可以看到H里面会对各种状态进行处理。LAUNCH_ACTIVITY中会调用handleLaunchActivity，继续往下看。
1private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
2 //...
3 Activity a = performLaunchActivity(r, customIntent);
4
5 if (a != null) {
6 r.createdConfig = new Configuration(mConfiguration);
7 reportSizeConfigurations(r);
8 Bundle oldState = r.state;
9 //这里最终会调用Activity的onResume生命周期
10 handleResumeActivity(r.token, false, r.isForward,
11 !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
12 //...
13}
14
15private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
16
17 //从ActivityClientRecord中获取要启动的Activity信息
18
19 ActivityInfo aInfo = r.activityInfo;
20 if (r.packageInfo == null) {
21 r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
22 Context.CONTEXT_INCLUDE_CODE);
23 }
24
25 ComponentName component = r.intent.getComponent();
26 if (component == null) {
27 component = r.intent.resolveActivity(
28 mInitialApplication.getPackageManager());
29 r.intent.setComponent(component);
30 }
31
32 if (r.activityInfo.targetActivity != null) {
33 component = new ComponentName(r.activityInfo.packageName,
34 r.activityInfo.targetActivity);
35 }
36
37 //ContextImpl在这里创建，ContextImpl是Context的具体实现
38 ContextImpl appContext = createBaseContextForActivity(r);
39 Activity activity = null;
40
41 try {
42 java.lang.ClassLoader cl = appContext.getClassLoader();
43
44 //通过Instrumentation的newActivity使用类加载器来创建Activity对象
45 activity = mInstrumentation.newActivity(
46 cl, component.getClassName(), r.intent);
47 StrictMode.incrementExpectedActivityCount(activity.getClass());
48 r.intent.setExtrasClassLoader(cl);
49 r.intent.prepareToEnterProcess();
50 if (r.state != null) {
51 r.state.setClassLoader(cl);
52 }
53 }
54
55 try {
56 //创建Application对象，如果已经创建过，则不会重复创建，保证一个应用中只有一个Application对象;
57 //实际上跟Activity一样也是在Instrumentation中使用类加载器来创建的
58 Application app = r.packageInfo.makeApplication(false, mInstrumentation);
59
60 if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
61 if (localLOGV) Slog.v(
62 TAG, r + ": app=" + app
63 + ", appName=" + app.getPackageName()
64 + ", pkg=" + r.packageInfo.getPackageName()
65 + ", comp=" + r.intent.getComponent().toShortString()
66 + ", dir=" + r.packageInfo.getAppDir());
67
68 if (activity != null) {
69 //...
70
71 //attach中会建立Activity与ContextImpl的联系
72 //attach中还会创建Window并与Window建立联系 可以看Activivity中的源码
73 activity.attach(appContext, this, getInstrumentation(), r.token,
74 r.ident, app, r.intent, r.activityInfo, title, r.parent,
75 r.embeddedID, r.lastNonConfigurationInstances, config,
76 r.referrer, r.voiceInteractor, window, r.configCallback);
77
78 //...
79
80 if (r.isPersistable()) {
81 //回调Activity的OnCreate
82 mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
83 } else {
84 //回调Activity的OnCreate
85 mInstrumentation.callActivityOnCreate(activity, r.state);
86 }
87
88 //...
89 return activity;
90}
可以看出，最终调用了Instrumentation的callActivityOnCreate方法，感觉离目的地越来越近了！
Instrumentation的callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}Activity的performCreate
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {
onCreate(icicle, persistentState);//onCreate
} else {
onCreate(icicle);//onCreate
}
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
}可以看到，onCreate被调用起来了。至此，Activity被启动起来了。
最后，放张总的时序图（图太大，请另外打开或保存）：
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
