Activity的启动流程
参考 AMS分析「 Activity启动流程 」https://www.jianshu.com/p/501690f88f68
上面这篇文章讲解的比较详细，通过一个一个方法的调用流程进行讲解，很不错，感谢。由于打算作为面试前的整理，所以参考此文章做了一些总结性的语句，方便在面试中回答，部分源码可能与该文章中不同，文中“概述”部分可以作为面试的回答，由于能力尚浅，不对或不准确的地方大佬们要指正，我渴望进步。
Activity启动流程示意图
主要是原Activity和目标Activity与AMS的通信。
Activity启动流程分析
一、Activity A与AMS通信
概述
- 1.Activity A调用startActivity方法通过一系列重载方法最终调用startActivityForResult方法，通过Instrumentation的execStartActivity方法利用mMainThread.getApplicationThread得到的Binder对象和mToken参数与AMS建立通信联系，并将启动Activity B的信息Intent传递给AMS；
- 2.接下来通过获取AMS的代理对象调用AMS的startActivity方法进而获取到要启动的Activity B的一些信息并创建其ActivityRecord对象，之后会通过调用方所在进程的Binder对象实现进程间通信，通知应用程序Activity A可以进去Paused状态了。
- 3.Activity A收到消息调用一系列方法进入Paused状态，并通过代理对象通知AMS已经Paused，AMS收到通知会移除刚才通知Activity A休眠的消息，并标记Activity A已经休眠，接下来做启动Activity B的一些准备工作。
（1）Activity A通知AMS要启动Activity B
Activity A调用startActivity方法，最终调用startActivityForResult方法（requestCode为-1表示不需要返回结果）
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
startActivityForResult方法中：
- mMainThread.getApplicationThread()返回的是一个ApplicationThread类型的Binder对象，可以实现与AMS的通信；
- mToken同样是个Binder对象，它会指向AMS中保存的调用方Activity A的ActivityRecord信息，AMS根据它就可以获取Activity A的信息；
- 最终调用了Instrumentation的execStartActivity方法来启动Activity。应用程序和系统之间的交互都集中交给Instrumentation来做，方便系统对这些活动的监视。
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
//....
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
//.....
} else {
//....
}
}
Instrumentation的execStartActivity方法，通过ActivityManagerNative.getDefault()【我看的源码是这样获取的ActivityTaskManager.getService()】获取AMS的代理对象，调用AMS的startActivity，这样后续工作就来到了AMS中。
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode) {
//传进来的mMainThread.getApplicationThread
IApplicationThread whoThread = (IApplicationThread) contextThread;
//....
try {
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
null, 0, token, target != null ? target.mEmbeddedID : null,
requestCode, false, false);
//....
} catch (RemoteException e) {
}
return null;
}
（2）AMS收到通知保存信息，通知Activity A可以去休眠了
进入AMS，调用AMS的startActivity方法
public final int startActivity(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug) {
//IApplicationThread caller就是传进来的mMainThread.getApplicationThread的Binder对象
//IBinder resultTo 就是传进来的mToken，指向Activity A的ActivityRecord的Binder对象
return mMainStack.startActivityMayWait(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, resultTo, resultWho,
requestCode, onlyIfNeeded, debug, null, null);
}
ActivityStack的startActivityMayWait方法
mMainStack为ActivityStack，（参考的文中是ActivityStackSupervisor），源码中关于ActivityStack的注释 State and management of a single stack of activities.，大概意思对Activity的状态和对Activity的管理的Stack。在AMS启动的时候创建的。
final int startActivityMayWait(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug, WaitResult outResult, Configuration config) {
//.....
//PMS服务根据intent查询要启动的Activity B的信息，保存到ActivityInfo中
intent = new Intent(intent);
ActivityInfo aInfo;
try {
ResolveInfo rInfo =
AppGlobals.getPackageManager().resolveIntent(
intent, resolvedType,
PackageManager.MATCH_DEFAULT_ONLY
| ActivityManagerService.STOCK_PM_FLAGS);
aInfo = rInfo != null ? rInfo.activityInfo : null;
} catch (RemoteException e) {
aInfo = null;
}
if (aInfo != null) {
intent.setComponent(new ComponentName(
aInfo.applicationInfo.packageName, aInfo.name));
//....
}
synchronized (mService) {
//.....
int res = startActivityLocked(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, aInfo,
resultTo, resultWho, requestCode, callingPid, callingUid,
onlyIfNeeded, componentSpecified);
//.....
return res;
}
}
ActivityStack的startActivityLocked方法
final int startActivityLocked(IApplicationThread caller,
Intent intent, String resolvedType,
Uri[] grantedUriPermissions,
int grantedMode, ActivityInfo aInfo, IBinder resultTo,
String resultWho, int requestCode,
int callingPid, int callingUid, boolean onlyIfNeeded,
boolean componentSpecified) {
int err = START_SUCCESS;
//找到调用方（Activity A所在进程）所在进程在AMS中ProcessRecord对象，
//然后通过它获取调用方的pid和uid
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
//....
}
}
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
//通过传进来的mToken获取查找对应的ActivityRecord的索引index
int index = indexOfTokenLocked(resultTo);
if (index >= 0) {
//获取调用方Activity A的ActivityRecord
sourceRecord = (ActivityRecord)mHistory.get(index);
if (requestCode >= 0 && !sourceRecord.finishing) {
resultRecord = sourceRecord;
}
}
}
int launchFlags = intent.getFlags();
//.....
//根据调用方Activity A的信息创建目标Activity B的ActivityRecord对象
ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
intent, resolvedType, aInfo, mService.mConfiguration,
resultRecord, resultWho, requestCode, componentSpecified);
//.....
将刚创建的Activity B的ActivityRecord对象传入startActivityUncheckedLocked进行进一步操作
return startActivityUncheckedLocked(r, sourceRecord,
grantedUriPermissions, grantedMode, onlyIfNeeded, true);
}
ActivityStack的startActivityUncheckedLocked方法
final int startActivityUncheckedLocked(ActivityRecord r,
ActivityRecord sourceRecord, Uri[] grantedUriPermissions,
int grantedMode, boolean onlyIfNeeded, boolean doResume) {
final Intent intent = r.intent;
final int callingUid = r.launchedFromUid;
int launchFlags = intent.getFlags();
//获取启动模式，默认应该是标准模式
if (sourceRecord == null) {
if ((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
}
} else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
} else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE
|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
}
//获取Activity A所在的Task，将其作为目标Activity B的Task
//....
int where = findActivityInHistoryLocked(r, sourceRecord.task.taskId);
if (where >= 0) {
///获取ActivityStack中的 top Task是不是和当前的Task一致，如果不一致则将当前的Task移动到ActivityStack的顶端
ActivityRecord top = moveActivityToFrontLocked(where);
//...
return START_DELIVERED_TO_TOP;
}
//....
//将Activity A的Stack作为Activity B的Stack
r.task = sourceRecord.task;
//最后调用startActivityLocked方法
startActivityLocked(r, newTask, doResume);
}
ActivityStack的startActivityLocked方法：遍历当前stack中所有的Task,找到目标task,然后将即将要启动的Activity加入到Task的栈顶
private final void startActivityLocked(ActivityRecord r, boolean newTask,
boolean doResume) {
final int NH = mHistory.size();
int addPos = -1;
//遍历当前stack中所有的Task,找到目标task,然后将即将要启动的Activity加入到Task的栈顶
if (!newTask) {
boolean startIt = true;
for (int i = NH-1; i >= 0; i--) {
ActivityRecord p = (ActivityRecord)mHistory.get(i);
if (p.finishing) {
continue;
}
if (p.task == r.task) {
addPos = i+1;
if (!startIt) {
mHistory.add(addPos, r);
r.inHistory = true;
r.task.numActivities++;
mService.mWindowManager.addAppToken(addPos, r, r.task.taskId,
r.info.screenOrientation, r.fullscreen);
//...
return;
}
break;
}
if (p.fullscreen) {
startIt = false;
}
}
}
// Place a new activity at top of stack, so it is next to interact
// with the user.
if (addPos < 0) {
addPos = NH;
}
//...
mHistory.add(addPos, r);
r.inHistory = true;
r.frontOfTask = newTask;
r.task.numActivities++;
//...
if (doResume) {
resumeTopActivityLocked(null);
}
}
ActivityStack的resumeTopActivityLocked方法
final boolean resumeTopActivityLocked(ActivityRecord prev) {
//找到栈顶第一个不是处于finishing状态的ActicityRecord
// Find the first activity that is not finishing.
ActivityRecord next = topRunningActivityLocked(null);
//...
if (mResumedActivity != null) {
if (DEBUG_SWITCH) Slog.v(TAG, "Skip resume: need to start pausing");
startPausingLocked(userLeaving, false);
return true;
}
}
ActivityStack的startPausingLocked方法
//获取应用程序的代理对象调用其schedulePauseActivity方法通知Activity A可以进入Paused状态去休眠了，并做一些
private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {
//...
//Activity A 的ActivityRecord
ActivityRecord prev = mResumedActivity;
mResumedActivity = null;
mPausingActivity = prev;
mLastPausedActivity = prev;
prev.state = ActivityState.PAUSING;
//获取应用程序的代理对象调用其schedulePauseActivity方法通知Activity A可以进入Paused状态去休眠了
if (prev.app != null && prev.app.thread != null) {
try {
prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving,
prev.configChangeFlags);
if (mMainStack) {
mService.updateUsageStats(prev, false);
}
} catch (Exception e) {
mPausingActivity = null;
mLastPausedActivity = null;
}
} else {
mPausingActivity = null;
mLastPausedActivity = null;
}
//...
}
（3）Activity A收到通知进入Paused状态，通知AMS已经休眠，接下来就全靠AMS了
调用ActivityThread内部类ApplicationThread的schedulePauseActivity方法，发送PAUSE_ACTIVITY的消息
//参数token就是Activity A传给AMS标记Activity A信息的Binder对象
//finished为false，选择PAUSE_ACTIVITY
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) {
queueOrSendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? 1 : 0),
configChanges);
}
private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
synchronized (this) {
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;
mH.sendMessage(msg);
}
}
在Handler的handleMessage方法中处理消息
public void handleMessage(Message msg) {
switch (msg.what) {
//...
case PAUSE_ACTIVITY:
handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
//...
break;
//....
}
}
ActivityThread中handlePauseActivity方法：执行Activity A的onPause方法，等待pause状态的数据写入完成，获取AMS代理对象通知AMS已经进入Paused状态了。
private final void handlePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges) {
//通过token获取ActivityClientRecord（Activity A的信息）
ActivityClientRecord r = mActivities.get(token);
if (r != null) {
if (userLeaving) {
performUserLeavingActivity(r);
}
r.activity.mConfigChangeFlags |= configChanges;
Bundle state = performPauseActivity(token, finished, true);
//等待pause状态数据写如完成
QueuedWork.waitToFinish();
// Tell the activity manager we have paused.
try {
ActivityManagerNative.getDefault().activityPaused(token, state);
} catch (RemoteException ex) {
}
}
}
（4）AMS收到Activity A已经休眠的消息，移除通知Activity A进入Paused状态的超时消息，并做最后移除Activity A的所在Task的一些信息等操作进一步准备启动目标Activity B所需工作。
AMS的activityPaused方法
public final void activityPaused(IBinder token, Bundle icicle) {
// Refuse possible leaked file descriptors
if (icicle != null && icicle.hasFileDescriptors()) {
throw new IllegalArgumentException("File descriptors passed in Bundle");
}
final long origId = Binder.clearCallingIdentity();
mMainStack.activityPaused(token, icicle, false);
Binder.restoreCallingIdentity(origId);
}
ActivityStack的activityPaused方法
final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {
ActivityRecord r = null;
synchronized (mService) {
int index = indexOfTokenLocked(token);
if (index >= 0) {
r = (ActivityRecord)mHistory.get(index);
//...
//移除Paused状态的超时消息
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
if (mPausingActivity == r) {
r.state = ActivityState.PAUSED;
completePauseLocked();
} else {
//...
}
}
}
}
ActivityStack的completePauseLocked方法
private final void completePauseLocked() {
ActivityRecord prev = mPausingActivity;
if (prev != null) {
//....
//检车AMS是否处于激活状态
if (!mService.mSleeping && !mService.mShuttingDown) {
resumeTopActivityLocked(prev);
}
//....
}
}
ActivityStack的resumeTopActivityLocked
final boolean resumeTopActivityLocked(ActivityRecord prev) {
//找到栈顶的Activity，此时栈顶的acitvity就是即将要启动的Activity B
ActivityRecord next = topRunningActivityLocked(null);
//...
//在前面Activity A变为pause状态的时候，我们就把mResumeActivity 置为了Null
if (mResumedActivity != null) {
if (DEBUG_SWITCH) Slog.v(TAG, "Skip resume: need to start pausing");
startPausingLocked(userLeaving, false);
return true;
}
//.....
if (next.app != null && next.app.thread != null) {
//新的Activity B 所在的进程还没有创建
//....
} else {
//....
//会调用此方法后续创建目标Activity B的进程
startSpecificActivityLocked(next, true, true);
}
return true;
}
二、AMS和目标Activity B通信
概述
- 获取到AMS中保存的目标进行的信息，调用Process的start方法创建进程；
- Zygote进程会fork一个新的子进程出来，子进程创建完成之后，classLoader加载ActivityThread类并创建一个ActivityThread实例，反射调用ActivityThread的main方法，创建Looper并创建消息队列开始消息循环。
- 进程创建完成后开始启动目标Activity B，调用handleLaunchActivity，内部调用performLaunchActivity通过ClassLoader加载Activity类，创建Activity并调用onCreate方法做一些初始化的工作，Activity启动完成后，调用handlResumeActivity来使Activity进入resume激活状态。
（1）获取到保存的目标进程和Activity的信息开始创建新的进程
ActivityStack的startSpecificActivityLocked
获取AMS中保存的目标Activity B所在进程的信息，调用AMS的startProcessLocked方法创建新的进程
private final void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid);
//....
if (app != null && app.thread != null) {
//目前目标进程还没有创建
//....
}
//调用AMS的startProcessLocked方法创建新的进程
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false);
}
AMS的startProcessLocked方法
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting) {
//获取目标进程的ProcessRecord对象
ProcessRecord app = getProcessRecordLocked(processName, info.uid);
//...
String hostingNameStr = hostingName != null
? hostingName.flattenToShortString() : null;
//....
startProcessLocked(app, hostingType, hostingNameStr);
return (app.pid != 0) ? app : null;
}
AMS的另一个startProcessLocked重载方法
private final void startProcessLocked(ProcessRecord app,
String hostingType, String hostingNameStr) {
//....
try {
int uid = app.info.uid;
int[] gids = null;
try {
gids = mContext.getPackageManager().getPackageGids(
app.info.packageName);
} catch (PackageManager.NameNotFoundException e) {
Slog.w(TAG, "Unable to retrieve gids", e);
}
//....
//Process的start方法创建进程
int pid = Process.start("android.app.ActivityThread",
mSimpleProcessManagement ? app.processName : null, uid, uid,
gids, debugFlags, null);
//....
} catch (RuntimeException e) {
// XXX do better error recovery.
app.pid = 0;
Slog.e(TAG, "Failure starting process " + app.processName, e);
}
}
Zygote进程会fork一个新的子进程出来，子进程创建完成之后，classLoader加载ActivityThread类并创建一个ActivityThread实例，反射调用ActivityThread的main方法。这样ActivityThread主线程就在新的进程中启动起来了。
ActivityThread中的main方法
创建消息队列，并且looper开始消息循环，是当前线程成为新进程的主线程，创建新的ActivityThread对象，并调用attach方法
public static final void main(String[] args) {
Looper.prepareMainLooper();
if (sMainThreadHandler == null) {
sMainThreadHandler = new Handler();
}
ActivityThread thread = new ActivityThread();
thread.attach(false);
Looper.loop();
thread.detach();
}
}
ActivityThread的attach方法，获取AMS的代理对象，调用attachApplication方法
//传进来system为false
private final void attach(boolean system) {
//利用ThreadLocal保存当前线程
sThreadLocal.set(this);
//说明不是系统进程
mSystemThread = system;
if (!system) {
// ....
IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
}
} else {
//...
}
}
（2）通知AMS新的进程已经创建
AMS的attachApplication
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
AMS的attachApplicationLocked方法
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
ProcessRecord app;
//获取ProcessRecord对象
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
} else if (mStartingProcesses.size() > 0) {
app = mStartingProcesses.remove(0);
app.setPid(pid);
} else {
app = null;
}
try {
//....
//thread就是新进程的ApplicationThread的代理端Binder对象
thread.bindApplication(processName, app.instrumentationInfo != null
? app.instrumentationInfo : app.info, providers,
app.instrumentationClass, app.instrumentationProfileFile,
app.instrumentationArguments, app.instrumentationWatcher, testMode,
isRestrictedBackupMode || !normalMode,
mConfiguration, getCommonServicesLocked());
} catch (Exception e) {
app.resetPackageList();
startProcessLocked(app, "bind fail", processName);
return false;
}
//.....
return true;
}
ActivityThread内部类ApplicationThread的bindApplication方法
通过新进程的ApplicationThread的代理对象
public final void bindApplication(String processName,
ApplicationInfo appInfo, List<ProviderInfo> providers,
ComponentName instrumentationName, String profileFile,
Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
int debugMode, boolean isRestrictedBackupMode, Configuration config,
Map<String, IBinder> services) {
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.profileFile = profileFile;
data.instrumentationArgs = instrumentationArgs;
data.instrumentationWatcher = instrumentationWatcher;
data.debugMode = debugMode;
data.restrictedBackupMode = isRestrictedBackupMode;
data.config = config;
queueOrSendMessage(H.BIND_APPLICATION, data);
}
发送消息，在H的handleMessage方法中处理消息
调用handleBindApplication方法来进一步处理新进程的运行环境的初始化。主要是新进程Application的初始化，Instrumentation的初始化和安装相关的ContentProvider.。
public void handleMessage(Message msg) {
switch (msg.what) {
//....
case BIND_APPLICATION:
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
break;
//....
}
}
（3）新的进程启动Activity B
调用ActivityStack的realStartActivityLocked方法，调用新的进程的主线程启动Activity B
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
r.app = app;
int idx = app.activities.indexOf(r);
if (idx < 0) {
app.activities.add(r);
}
mService.updateLruProcessLocked(app, true, true);
try {
//....
//调用新进程的主线程启动Activity B
app.thread.scheduleLaunchActivity(new Intent(r.intent), r,
System.identityHashCode(r),
r.info, r.icicle, results, newIntents, !andResume,
mService.isNextTransitionForward());
} catch (RemoteException e) {
//....
throw e;
}
//.....
return true;
}
ActivityThread的内部类ApplicationThread的scheduleLaunchActivity方法，获取到保存在ActivityClientRecord的要启动的Activity B的信息，发送H.LAUNCH_ACTIVITY消息启动Activity B
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.activityInfo = info;
r.state = state;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
}
Handler的handleMessage方法中处理消息
public void handleMessage(Message msg) {
switch (msg.what) {
//....
case LAUNCH_ACTIVITY: {
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo);
handleLaunchActivity(r, null);
} break;
//....
}
}
ActivityThread的handleLaunchActivity方法
private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//调用performLaunchActivity方法来启动Activity
Activity a = performLaunchActivity(r, customIntent);
//Activity启动完成后，调用handlResumeActivity来使Activity进入resume激活状态
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward);
//....
} else {
//如果发生错误 通知AMS
// If there was an error, for any reason, tell the activity
// manager to stop us.
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null);
} catch (RemoteException ex) {
}
}
}
ActivityThread的performLaunchActivity方法启动Activity调用onCreate方法，做一些Activity的初始化工作
private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//获取ActivityInfo
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo,
Context.CONTEXT_INCLUDE_CODE);
}
//获取component
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
//ClassLoader加载对应的Activity类
//通过Instrumentation调用newActivity方法创建Activity
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
//....
}
try {
//创建Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
//创建上下文对象并与Activity关联
ContextImpl appContext = new ContextImpl();
appContext.init(r.packageInfo, r.token, this);
appContext.setOuterContext(activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
//创建Activity的Configuration对象
Configuration config = new Configuration(mConfiguration);
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstance,
r.lastNonConfigurationChildInstances, config);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstance = null;
r.lastNonConfigurationChildInstances = null;
activity.mStartedActivity = false;
//获取主题样式并设置
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
//调用Activity的onCreate方法
mInstrumentation.callActivityOnCreate(activity, r.state);
r.activity = activity;
r.stopped = true;
//调用onStart方法
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
if (!r.activity.mFinished) {
if (r.state != null) {
//调用callActivityOnRestoreInstanceState mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
//调用callActivityOnPostCreate
mInstrumentation.callActivityOnPostCreate(activity, r.state);
//...
}
}
//把创建的对应的ActivityClientRecord以binder为键值，保存到mActivities中
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
//....
}
return activity;
}
727
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
