activity是Android的四大组件之一，也是平常开发中使用最频繁的组件，但是我们在使用的时候有没有考虑过activity是如何创建、启动的尼？下面就来梳理一下activity的启动流程，先来看一张activity启动的流程图，然后在进行详细的代码分析。
先对activity启动要涉及到的类做个简单介绍
- Instrumentation：每一个应用程序只有一个Instrumentation对象，每个Activity内都有一个对该对象的引用。Instrumentation可以理解为应用进程的管家，ActivityThread要创建或暂停某个Activity时，都需要通过Instrumentation来进行具体的操作。
- ActivitymanagerService：简称AMS，服务端对象，负责系统中所有Activity的生命周期
- ActivityStarter：收集用于确定如何转换intent和flags的所有逻辑，比如根据Intent来找到具体的activity
- ActivityStackSupervisor：主要负责管理ActivityStack
- ActivityStack：Activity在AMS的栈管理，用来记录已经启动的Activity的先后关系，状态信息等。通过ActivityStack决定是否需要启动新的进程。
- ApplicationThread：用来实现ActivityManagerService与ActivityThread之间的交互。在ActivityManagerService需要管理相关Application中的Activity的生命周期时，通过ApplicationThread的代理对象与ActivityThread通讯。
- ActivityThread：App的真正入口。当开启App之后，会调用main()开始运行，开启消息循环队列，这就是传说中的UI线程或者叫主线程。与ActivityManagerServices配合，一起完成Activity的管理工作
- ActivityRecord：ActivityStack的管理对象，每个Activity在AMS对应一个ActivityRecord，来记录Activity的状态以及其他的管理信息。其实就是服务器端的Activity对象的映像。
- TaskRecord：AMS抽象出来的一个“任务”的概念，是记录ActivityRecord的栈，一个“Task”包含若干个ActivityRecord。AMS用TaskRecord确保Activity启动和退出的顺序。如果你清楚Activity的4种launchMode，那么对这个概念应该不陌生。
activity启动有两种情况
- 通过startActivity或者startActivityForResult来启动一个新的Activity
- 通过startActivity启动一个Android应用
启动一个新的activity很简单，直接调用startActivity或者startActivityForResult即可。那如何启动一个Android应用尼？其实我们打开手机看到的应用图标的界面也是一个activity，它属于系统应用，先来看看这个activity
public abstract class LauncherActivity extends ListActivity {
...
//布局界面
protected void onSetContentView() {
setContentView(com.android.internal.R.layout.activity_list);
}
//启动一个Android应用
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
Intent intent = intentForPosition(position);
startActivity(intent);
}
...
}
从上面代码发现启动一个应用也是startActivity来实现的，这跟启动一个新的activity都调用同一方法。那么就来看startActivity的具体实现过程。查看源码发现startActivity最终会调用activity中的startActivityForResult方法。默认requestCode为-1，也就是说startActivityForResult(intent,-1)==startActivity。
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
...
} else {
...
}
}
在startActivityForResult方法里是调用了Instrumentation的execStartActivity方法，execStartActivity里通过Binder机制来连接AMS(ActivityManagerService)并调用AMS的startActivity方法。
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
在startActivity里会调用startActivityAsUser方法，然后再调用startActivityMayWait来方法。
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
...
// TODO: Switch to user app stacks here.
return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
profilerInfo, null, null, bOptions, false, userId, null, null,
"startActivityAsUser");
}
ActivityStarter主要是用于收集所有逻辑，用于确定如何将intent和flag转换为activity以及关联的任务和堆栈。在ActivityStarter的startActivityMayWait的方法里，对Intent进行验证、解析然后拿到ResolveInfo及activity信息，之后调用startActivityLocked方法
final int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, Intent intent, String resolvedType,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,
Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
IActivityContainer iContainer, TaskRecord inTask, String reason) {
// Refuse possible leaked file descriptors
if (intent != null && intent.hasFileDescriptors()) {
...
//解析Intent的信息
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
...
// Collect information about the target of the Intent.
//从ResolveInfo拿出ActivityInfo
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
...
final ActivityRecord[] outRecord = new ActivityRecord[1];
int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor,
resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
options, ignoreTargetSecurity, componentSpecified, outRecord, container,
inTask, reason);
...
return res;
}
}
在拿到activity信息后并根据启动模式来创建一个ActivityRecord保存，然后调用startActivityUnchecked方法。从该方法就可以看出activity前期的准备已经做完，后面就可以对栈顶的activity进行出栈及新activity的创建。
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
...
mIntent.setFlags(mLaunchFlags);//设置启动模式
...
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
...
} else {
...
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
} else {
mTargetStack.addRecentActivityLocked(mStartActivity);
}
...
return START_SUCCESS;
}
在startActivityUnchecked里，系统会调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked，从而最终调用ActivityStack的resumeTopActivityUncheckedLocked方法，在resumeTopActivityUncheckedLocked里会调用resumeTopActivityInnerLocked这个方法，这个方法就非常重要了，无论是栈顶activity的暂停、应用的创建、activity的创建都会在此方法里调用
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
//暂停当前栈顶的activity
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
pausing |= startPausingLocked(userLeaving, false, next, false);
}
if (pausing && !resumeWhilePausing) {
...
return true;
} else if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
mStackSupervisor.allResumedActivitiesComplete()) {
...
return true;
}
...
ActivityStack lastStack = mStackSupervisor.getLastStack();
if (next.app != null && next.app.thread != null) {
...
} else {
// Whoops, need to restart this activity!
...
//这里开启一个新的activity（application、activity的创建）
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
...
return true;
}
由于需要先暂停栈顶的activity，所有就会先进入startPausingLocked方法，在startPausingLocked方法里，有这么一句很重要的代码
prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
userLeaving, prev.configChangeFlags, pauseImmediately);
就是进入ApplicationThread的schedulePauseActivity，在schedulePauseActivity里会调用ActivityThread的handlePauseActivity方法。
private void handlePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport, int seq) {
...
if (r != null) {
//Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
if (userLeaving) {
performUserLeavingActivity(r);
}
r.activity.mConfigChangeFlags |= configChanges;
//回调activity的onPause方法，如果异常关闭的话，也会调用OnSaveInstanceState方法
performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
// Make sure any pending writes are now committed.
if (r.isPreHoneycomb()) {
//需要完成QueuedWork里的任务（阻塞的），QueuedWork实际上是一个HandlerThread在处理任务，所以不能有耗时操作
QueuedWork.waitToFinish();
}
// Tell the activity manager we have paused.
if (!dontReport) {
try {
//暂停完毕开始回调下一步生命周期
ActivityManager.getService().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
mSomeActivitiesChanged = true;
}
}
当栈顶activity暂停完毕后，则进入AMS的activityPaused方法，从而进入了ActivityStack的activityPausedLocked方法。到这里栈顶的activity就暂停完毕，可以创建新的activity或启动一个新的应用，然后再进入completePauseLocked方法里。如果是要关闭当前activity（当调用finish时），则进入finishCurrentActivityLocked方法里。
final ActivityRecord finishCurrentActivityLocked(ActivityRecord r, int mode, boolean oomAdj) {
...
if (mode == FINISH_IMMEDIATELY
|| (prevState == ActivityState.PAUSED
&& (mode == FINISH_AFTER_PAUSE || mStackId == PINNED_STACK_ID))
|| finishingActivityInNonFocusedStack
|| prevState == STOPPING
|| prevState == STOPPED
|| prevState == ActivityState.INITIALIZING) {
r.makeFinishingLocked();
//destroyActivityLocked方法里会调用activity的onDestory
boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm");
if (finishingActivityInNonFocusedStack) {
// Finishing activity that was in paused state and it was in not currently focused
// stack, need to make something visible in its place.
mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}
if (activityRemoved) {
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
...
return activityRemoved ? null : r;
}
...
return r;
}
在destroyActivityLocked方法里就会调用activity的最后一个生命周期onDestory。
final boolean destroyActivityLocked(ActivityRecord r, boolean removeFromApp, String reason) {
...
if (hadApp) {
...
boolean skipDestroy = false;
try {
r.app.thread.scheduleDestroyActivity(r.appToken, r.finishing,
r.configChangeFlags);
} catch (Exception e) {
...
}
}
...
return removedFromHistory;
}
这样就通过ApplicationThread调用了ActivityThread的handleDestroyActivity方法，从而调用activity的onDestory方法。
再回到completePauseLocked方法中
private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
...
if (prev != null) {
final boolean wasStopping = prev.state == STOPPING;
prev.state = ActivityState.PAUSED;
if (prev.finishing) {
//关闭当前activity，会调用activity的onDestory
prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false);
} else if (prev.app != null) {//当启动一个应用时会进入
...
} else {
...
}
...
}
if (resumeNext) {
final ActivityStack topStack = mStackSupervisor.getFocusedStack();
if (!mService.isSleepingOrShuttingDownLocked()) {
mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
} else {
mStackSupervisor.checkReadyForSleepLocked();
ActivityRecord top = topStack.topRunningActivityLocked();
if (top == null || (prev != null && top != prev)) {
//启动一个新的application或者activity
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
}
}
...
}
当启动activity时会进入ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法，从而进入ActivityStack的resumeFocusedStackTopActivityLocked里，从而进入resumeTopActivityInnerLocked方法里，resumeTopActivityInnerLocked这个方式是不是很熟悉，暂停栈顶activity时也会进入这个方法里。但这次就不暂停activity了，而是启动一个新的activity或者新的应用，那么就会进入ActivityStackSupervisor的startSpecificActivityLocked方法里。
//由completePauseLocked方法进入
boolean resumeFocusedStackTopActivityLocked() {
return resumeFocusedStackTopActivityLocked(null, null, null);
}
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.state == RESUMED) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
在startSpecificActivityLocked方法里，可以看见是新创建一个activity还是创建一个应用
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.getStack().setLaunchTime(r);
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
//新创建一个activity
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
...
}
}
//创建一个新的进程，从而调用ActivityThread的main方法
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
首先来看如何启动一个新的activity，进入realStartActivityLocked方法可以发现如下代码：
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global and
// override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
这是通过调用applicationThread的scheduleLaunchActivity的方法来调用ActivityThread的handleLaunchActivity方法，在handleLaunchActivity方法里调用了activity的onCreate、onStart、onResume三个回调方法，
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
// Make sure we are running with the most recent config.
//配置改变（比如横竖屏切换）
handleConfigurationChanged(null, null);
...
// Initialize before creating the activity
WindowManagerGlobal.initialize();
//在performLaunchActivity里创建activity
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
...
}
} else {
//如果出现异常就关闭这个activity
try {
ActivityManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
在performLaunchActivity方法里创建新的activity并调用activity的onCreate及onstart方法，如果是异常终止恢复的话则会调用OnRestoreInstanceState方法，在handleResumeActivity里会调用activity的onResume方法，到此，启动一个新的activity流程就完毕了。
再回到startSpecificActivityLocked方法中，如果启动一个Android应用则会进入AMS里的startProcessLocked，从而进入startProcessLocked方法。
//启动一个新的进程
private final void startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
try {
if (hostingType.equals("webview_service")) {
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, entryPointArgs);
} else {
//开启新的进程
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, entryPointArgs);
}
synchronized (mPidsSelfLocked) {
this.mPidsSelfLocked.put(startResult.pid, app);
if (isActivityProcess) {
//超时判断
Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
msg.obj = app;
mHandler.sendMessageDelayed(msg, startResult.usingWrapper
? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);
}
}
} catch (RuntimeException e) {
...
}
}
启动进程成功后就会调用ActivityThread的main方法
public static void main(String[] args) {
//创建主线程的Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
//如果是系统应用则会传true
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//让主线程的Looper跑起来
Looper.loop();
}
这里可以发现主线程主线程为什么不需要创建Looper的原因（关于消息机制可以查看Android消息机制——Handler源码解析这篇文章），在main里调用了ActivityThread的attach方法。
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
//如果不是系统应用
if (!system) {
//拿到AMS的代理对象
final IActivityManager mgr = ActivityManager.getService();
try {
//开始创建application
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
...
}
//添加观察狗，当内存占用3/4以上时，就开始释放内存
BinderInternal.addGcWatcher(new Runnable() {
@Override public void run() {
//如果正在释放内存，则直接返回
if (!mSomeActivitiesChanged) {
return;
}
Runtime runtime = Runtime.getRuntime();
//最大内存大小
long dalvikMax = runtime.maxMemory();
//正在使用内存大小
long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
if (dalvikUsed > ((3*dalvikMax)/4)) {
mSomeActivitiesChanged = false;
try {
//释放内存
mgr.releaseSomeActivities(mAppThread);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
});
} else {//如果是系统应用
...
}
...
}
在attach里调用了AMS的attachApplication方法，然后在调用attachApplicationLocked方法
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
...
attachApplicationLocked(thread, callingPid);
...
}
}
//创建Application与activity、service等
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
// Find the application record that is being attached... either via
// the pid if we are running in multiple processes, or just pull the
// next app record if we are emulating process with anonymous threads.
ProcessRecord app;
long startTime = SystemClock.uptimeMillis();
//根据pid拿到进程信息
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
} else {
app = null;
}
//如果该进程不存在则退出
if (app == null) {
...
if (pid > 0 && pid != MY_PID) {
//杀死进程
killProcessQuiet(pid);
} else {
try {
//退出当前应用
thread.scheduleExit();
} catch (Exception e) {
// Ignore exceptions.
}
}
return false;
}
//清除残余信息
if (app.thread != null) {
handleAppDiedLocked(app, true, true);
}
...
//初始化进程信息
app.makeActive(thread, mProcessStats);
app.curAdj = app.setAdj = app.verifiedAdj = ProcessList.INVALID_ADJ;
app.curSchedGroup = app.setSchedGroup = ProcessList.SCHED_GROUP_DEFAULT;
app.forcingToImportant = null;
updateProcessForegroundLocked(app, false, false);
app.hasShownUi = false;
app.debugging = false;
app.cached = false;
app.killedByAm = false;
app.killed = false;
...
try {
...
//创建Application
if (app.instr != null) {
thread.bindApplication(processName, appInfo, providers,
app.instr.mClass,
profilerInfo, app.instr.mArguments,
app.instr.mWatcher,
app.instr.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
} else {
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
}
...
} catch (Exception e) {
...
return false;
}
...
boolean badApp = false;
boolean didSomething = false;
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
//启动第一个activity
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
...
badApp = true;
}
}
// Find any services that should be running in this process...
if (!badApp) {
try {
//启动第一个Service
didSomething |= mServices.attachApplicationLocked(app, processName);
} catch (Exception e) {
...
badApp = true;
}
}
// Check if a next-broadcast receiver is in this process...
if (!badApp && isPendingBroadcastProcessLocked(pid)) {
try {
//启动广播
didSomething |= sendPendingBroadcastsLocked(app);
...
} catch (Exception e) {
...
badApp = true;
}
}
// Check whether the next backup agent is in this process...
if (!badApp && mBackupTarget != null && mBackupTarget.app == app) {
...
try {
thread.scheduleCreateBackupAgent(mBackupTarget.appInfo,
compatibilityInfoForPackageLocked(mBackupTarget.appInfo),
mBackupTarget.backupMode);
} catch (Exception e) {
...
. badApp = true;
}
}
...
return true;
}
在attachApplicationLocked里可以发现thread.bindApplication(...)这句代码，它的实现是ApplicationThread的bindApplication方法，在bindApplication
里通过系统handler调用了ActivityThread的handleBindApplication方法
private void handleBindApplication(AppBindData data) {
...
// Continue loading instrumentation.
if (ii != null) {
...
final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
appContext.getClassLoader(), false, true, false);
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);
try {
final ClassLoader cl = instrContext.getClassLoader();
//创建Instrumentation
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
...
}
final ComponentName component = new ComponentName(ii.packageName, ii.name);
//初始化Instrumentation
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
...
} else {
mInstrumentation = new Instrumentation();
}
...
try {
//创建application对象
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
...
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
catch (Exception e) {
...
}
try {
//调用Application的onCreate方法
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
...
}
} finally {
StrictMode.setThreadPolicy(savedPolicy);
}
...
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
在handleBindApplication里就成功创建了application并调用了onCreate方法，通过反射创建的。再回到AMS中的attachApplicationLocked方法中，当Application创建成功后，就会通过mStackSupervisor.attachApplicationLocked(app)这句代码去创建第一个activity。
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = stacks.get(stackNdx);
if (!isFocusedStack(stack)) {
continue;
}
ActivityRecord hr = stack.topRunningActivityLocked();
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
//去创建activity
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) {
...
}
}
}
}
}
...
return didSomething;
}
在realStartActivityLocked中可以发现这段代码
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global and
// override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
上面这段代码是不是就很熟悉了啊，这就是前面梳理过的创建activity的方法，到此activity的启动流程就完毕了，是不是很复杂啊…
【参考文章】
【凯子哥带你学Framework】Activity启动过程全解析
Android Activity启动过程
Android Activity启动流程源码全解析（1）
扫一扫
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
