Activity启动过程

startActivity 最终调用
startActivityForResult 方法， 关注 mParent==null 的情况，调用
Instrumentation 的 execStartActivity 里面调用
ActivityManagerNative.getDefault().startActivity

而 AMS 继承自 ActivityManagerNative，而 ActivityManagerNative 继承 Binder 和实现了 IActivityManager 接口，所以 AMS 也是一个 Binder ，它是 IActivityManager 的具体实现。
ActivityManagerNative.getDefault() 返回的是一个 IActivityManager 类型的Binder对象，所以具体实现是 AMS。

所以启动过程转到 AMS 的 startActivity 方法。

AMS 的 startActivity 方法 返回值调用 startActivityAsUser
startActivityAsUser 返回值调用 mStackSupervisor.startActivityMayWait

所以转到 ActivityStackSupervisor.startActivityMayWait 方法 ，里面调用
startActivityLocked ，startActivityLocked 里面调用了 startActivityUncheckedLocked，
startActivityUncheckedLocked 里面又调用了 ActivityStack 的 resumeTopActivitiesLocked 方法。

所以启动过程转到 ActivityStack

在 resumeTopActivitiesLocked 方法里面调用了 resumeTopActivityInnerLocked
resumeTopActivityInnerLocked 调用了 ActivityStackSupervisor 的 startSpecificActivityLocked 方法

startSpecificActivityLocked 里面有一个 realStartActivityLocked 方法

在 realStartActivityLocked 里面，有一段这样的代码：

app.thread.scheduleLaunchActivity(
new Intent(r.intent),
r.appToken,
System.identityHashCode(r),
r.info,
new Configuration(mService.mConfiguration),
r.compat,
r.task.voiceInteractor,
app.repProcState,
r.icicle,
r.persistentState,
results,
newInstents,
!andResume,
mService.isNextTransitionForward(),
profilerInfo)

app.thread 的类型是 IApplicationThread，继承 IInterface，是一个 Binder 接口，声明了大量启动，停止 Activity 的接口，还包含了启动和停止服务的接口。所以 可以看出实现 IApplicationThread 的类完成了大量启动，停止 Activity 和启动和停止 Service 相关功能。

而实现 IApplicationThread 接口的是 ActivityThread 里面的内部类 ApplicationThread：

private class ApplicationThread extends ApplicationThreadNative

public abstract class ApplicationThreadNative extends Binder implements IApplicationThread

即 app.thread.scheduleLaunchActivity 就是 ApplicationThread 的 scheduleLaunchActivity 方法。

所以，Activity的启动过程最终回到 ApplicationThread 中，ApplicationThread 的 scheduleLaunchActivity 方法启动 Activity

在 scheduleLaunchActivity 实现中，最后向 H 这个 Handler 中 发送了消息，what 是 H.LAUNCH_ACTIVITY，转到 Handler 中，看对 LAUNCH_ACTIVITY 的处理，调用了 handleLaunchActivity 方法实现。

handleLaunchActivity 里面 ，performLaunchActivity 最终完成了 Activity 对象的创建和启动过程。

还有一个 handleResumeActivity 方法，里面调用被启动 Activity 的 onResume 这一生命周期方法

performLaunchActivity方法过程分析：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

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

        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.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);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
            if (localLOGV) Slog.v(
                    TAG, r + ": app=" + app
                    + ", appName=" + app.getPackageName()
                    + ", pkg=" + r.packageInfo.getPackageName()
                    + ", comp=" + r.intent.getComponent().toShortString()
                    + ", dir=" + r.packageInfo.getAppDir());

            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (r.overrideConfig != null) {
                    config.updateFrom(r.overrideConfig);
                }
                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                        + r.activityInfo.name + " with config " + config);
                Window window = null;
                if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                    window = r.mPendingRemoveWindow;
                    r.mPendingRemoveWindow = null;
                    r.mPendingRemoveWindowManager = null;
                }
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                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);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                if (!r.activity.mFinished) {
                    if (r.isPersistable()) {
                        if (r.state != null || r.persistentState != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                    r.persistentState);
                        }
                    } else if (r.state != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                    }
                }
                if (!r.activity.mFinished) {
                    activity.mCalled = false;
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    if (!activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                    }
                }
            }
            r.paused = true;

            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to start activity " + component
                    + ": " + e.toString(), e);
            }
        }

        return activity;
    }

整个方法可以分成 5 段来分析：
第一段：

       ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

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

参数 r 是 ActivityClientRecord 对象，所以这段是从 ActivityClientRecord 中获取待启动的 Activity 的组件信息。

第二段：

Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.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);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }

通过 Instrumentation 的 newActivity 方法使用类加载器创建 Activity 对象。（ClassLoader 是类加载器，newActivity 的实现就是通过类加载器创建 Activity）

第三段

  Application app = r.packageInfo.makeApplication(false, mInstrumentation);

packageInfo 是 LoadedApk 对象，第三段是通过 LoadedApk 的 makeApplication 方法创建 Application 对象。

public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        if (mApplication != null) {
            return mApplication;
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");

        Application app = null;

        String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }

        try {
            java.lang.ClassLoader cl = getClassLoader();
            if (!mPackageName.equals("android")) {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                        "initializeJavaContextClassLoader");
                initializeJavaContextClassLoader();
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            }
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } catch (Exception e) {
            if (!mActivityThread.mInstrumentation.onException(app, e)) {
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                throw new RuntimeException(
                    "Unable to instantiate application " + appClass
                    + ": " + e.toString(), e);
            }
        }
        mActivityThread.mAllApplications.add(app);
        mApplication = app;

        if (instrumentation != null) {
            try {
                instrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!instrumentation.onException(app, e)) {
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        }

        // Rewrite the R 'constants' for all library apks.
        SparseArray packageIdentifiers = getAssets(mActivityThread)
                .getAssignedPackageIdentifiers();
        final int N = packageIdentifiers.size();
        for (int i = 0; i < N; i++) {
            final int id = packageIdentifiers.keyAt(i);
            if (id == 0x01 || id == 0x7f) {
                continue;
            }

            rewriteRValues(getClassLoader(), packageIdentifiers.valueAt(i), id);
        }

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

        return app;
    }

首先如果存在 mApplication 得话，直接返回，所以可以看出一个应用只有一个 Application。

然后通过 Instrumentation 的 newApplication 方法创建 Application 对象。newApplication 方法内部也是跟Activity 一样通过类加载器完成的。Application 创建后，Instrumentation 调用 callApplicationOnCreate 方法来调用 Application 的 onCreate 方法。

第四段：

Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
    config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
        + r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
    window = r.mPendingRemoveWindow;
    r.mPendingRemoveWindow = null;
    r.mPendingRemoveWindowManager = null;
}
activity.attach(appContext, this, getInstrumentation(), r.token,
        r.ident, app, r.intent, r.activityInfo, title, r.parent,
        r.embeddedID, r.lastNonConfigurationInstances, config,
        r.referrer, r.voiceInteractor, window);

创建 ContextImpl 对象并通过 Activity 的 attach 方法来完成一些重要数据的初始化。见 createBaseContextForActivity 的实现。
ContextImpl 是 Context 的具体实现。ContextImpl 是通过 Activity 的 attach 方法和 Activity 建立关联的。这样当 Window 接收到外部输入事件后就可以将时间传递给 Activity。具体看 attach 实现。

第五段：

if (r.isPersistable()) {
    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
    mInstrumentation.callActivityOnCreate(activity, r.state);
}

mInstrumentation.callActivityOnCreate 调用 Activity 的 onCreate 方法。由于 onCreate 已经被调用，这意味着 Activity 已经完成了整个启动过程。

参考资料：《艺术探索》