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);