1：App启动流程
1：ActivityThread
它管理应用程序进程中主线程的执行、调度和执行活动、广播以及活动管理器请求的其他操作
ActivityThread初始化 ActivityThread thread = new ActivityThread(); thread.attach(false, startSeq);
2：获取到Ams调用接口（AIDL方式）
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
3：ActivityManager.getService()的实现类是activityManagerService
切换到ams的实现类中查看attachApplication函数的作用 attachApplicationLocked(thread, callingPid, callingUid, startSeq);
4：bindApplication启动应用中的application
thread.bindApplication(processName, appInfo, providers,
instr2.mClass,
profilerInfo, instr2.mArguments,
instr2.mWatcher,
instr2.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions);
参考加载
didSomething |= mServices.attachApplicationLocked(app, processName);
5：ActivityThread内部私有类ApplicationThread
发送handler信息：sendMessage(H.BIND_APPLICATION, data);、
6：ActivityThread内部类H执行
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
7：创建Instrumentation，然后通过Instrumentation加载application
用于实现应用程序检测代码的基类。当启用了instrumentation时，将在任何应用程序代码之前为您实例化该类，从而允许您监视系统与应用程序的所有交互。仪器通过AndroidManifest.xml文件“instrumentation标记”。
mInstrumentation.onCreate(data.instrumentationArgs);
执行应用程序{@link application#onCreate}方法的调用。默认实现只是调用该方法。
<p>注意：此方法将在{@link#onCreate（Bundle）}之后立即调用。
通常，插装测试在onCreate（）中启动它们的测试线程；您需要小心这些线程之间的争用。（好吧，在它和其他东西之间，但是让我们从这里开始。）
mInstrumentation.callApplicationOnCreate(app);
8：ActivityStackSupervisor
启动Activity的函数：realStartActivityLocked
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
if (realStartActivityLocked(activity, app,
top == activity /* andResume */, true /* checkConfig */)) {
didSomething = true;
}
realStartActivityLocked中的执行函数
//此处添加LauncheActivityItem
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), 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, mService.isNextTransitionForward(), profilerInfo));
//此处添加ResumeActivityItem
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.调用ClientLifecycleManager中的函数
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
9：ClientLifecycleManager
transaction.schedule();
10：ClientTransaction
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
11：ActivityThread内部私有类ApplicationThread
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
12：ActivityThread的父类ClientTransactionHandler
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
13：ActivityThread内部类H
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
14：TransactionExecutor:
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
15：executeCallbacks
final ClientTransactionItem item = callbacks.get(i);
log("Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState);
}
item.execute(mTransactionHandler, token, mPendingActions);
16：LauncheActivityItem
item为之前传入的LauncheActivityItem，查看LauncheActivityItem里面的execute函数
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
17：ActivityThread中的handleLaunchActivity
final Activity a = performLaunchActivity(r, customIntent);
18：performLaunchActivity中创建Activity的核心代码
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
19：创建activity之后，开始调用oncreate函数
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
20：Instrumentation，这里是真正调用onCreate函数的地方
执行活动{@link activity#onCreate}方法的调用。默认实现只是调用该方法。
prePerformCreate(activity);
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
21：14中的executeLifecycleState
// Execute the final transition with proper parameters. lifecycleItem.execute(mTransactionHandler, token, mPendingActions); lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
22：执行ResumeActivityItem中的.execute函数
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
23：ActivityThread中的handleResumeActivity函数
// TODO Push resumeArgs into the activity for consideration
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
if (r == null) {
// We didn't actually resume the activity, so skipping any follow-up actions.
return;
}
24：performResumeActivity
try {
r.activity.onStateNotSaved();
r.activity.mFragments.noteStateNotSaved();
checkAndBlockForNetworkAccess();
if (r.pendingIntents != null) {
deliverNewIntents(r, r.pendingIntents);
r.pendingIntents = null;
}
if (r.pendingResults != null) {
deliverResults(r, r.pendingResults, reason);
r.pendingResults = null;
}
r.activity.performResume(r.startsNotResumed, reason);
r.state = null;
r.persistentState = null;
r.setState(ON_RESUME);
}
25：Activity中的performResume，这里调用的是activity的onResume函数
mCalled = false; // mResumed is set by the instrumentation mInstrumentation.callActivityOnResume(this); writeEventLog(LOG_AM_ON_RESUME_CALLED, reason);