Activity啟動過程

startActivity 最終調(diào)用
startActivityForResult 方法， 關(guān)注 mParent==null 的情況，調(diào)用
Instrumentation 的 execStartActivity 里面調(diào)用
ActivityManagerNative.getDefault().startActivity

而 AMS 繼承自 ActivityManagerNative，而 ActivityManagerNative 繼承 Binder 和實(shí)現(xiàn)了 IActivityManager 接口，所以 AMS 也是一個 Binder ，它是 IActivityManager 的具體實(shí)現(xiàn)。
ActivityManagerNative.getDefault() 返回的是一個 IActivityManager 類型的Binder對象，所以具體實(shí)現(xiàn)是 AMS。

所以啟動過程轉(zhuǎn)到 AMS 的 startActivity 方法。

AMS 的 startActivity 方法 返回值調(diào)用 startActivityAsUser
startActivityAsUser 返回值調(diào)用 mStackSupervisor.startActivityMayWait

所以轉(zhuǎn)到 ActivityStackSupervisor.startActivityMayWait 方法 ，里面調(diào)用
startActivityLocked ，startActivityLocked 里面調(diào)用了 startActivityUncheckedLocked，
startActivityUncheckedLocked 里面又調(diào)用了 ActivityStack 的 resumeTopActivitiesLocked 方法。

所以啟動過程轉(zhuǎn)到 ActivityStack

在 resumeTopActivitiesLocked 方法里面調(diào)用了 resumeTopActivityInnerLocked
resumeTopActivityInnerLocked 調(diào)用了 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 的接口，還包含了啟動和停止服務(wù)的接口。所以 可以看出實(shí)現(xiàn) IApplicationThread 的類完成了大量啟動，停止 Activity 和啟動和停止 Service 相關(guān)功能。

而實(shí)現(xiàn) IApplicationThread 接口的是 ActivityThread 里面的內(nèi)部類 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 實(shí)現(xiàn)中，最后向 H 這個 Handler 中 發(fā)送了消息，what 是 H.LAUNCH_ACTIVITY，轉(zhuǎn)到 Handler 中，看對 LAUNCH_ACTIVITY 的處理，調(diào)用了 handleLaunchActivity 方法實(shí)現(xiàn)。

handleLaunchActivity 里面 ，performLaunchActivity 最終完成了 Activity 對象的創(chuàng)建和啟動過程。

還有一個 handleResumeActivity 方法，里面調(diào)用被啟動 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);
        }

參數(shù) 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 方法使用類加載器創(chuàng)建 Activity 對象。（ClassLoader 是類加載器，newActivity 的實(shí)現(xiàn)就是通過類加載器創(chuàng)建 Activity）

第三段

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

packageInfo 是 LoadedApk 對象，第三段是通過 LoadedApk 的 makeApplication 方法創(chuàng)建 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<String> 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 得話，直接返回，所以可以看出一個應(yīng)用只有一個 Application。

然后通過 Instrumentation 的 newApplication 方法創(chuàng)建 Application 對象。newApplication 方法內(nèi)部也是跟Activity 一樣通過類加載器完成的。Application 創(chuàng)建后，Instrumentation 調(diào)用 callApplicationOnCreate 方法來調(diào)用 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);

創(chuàng)建 ContextImpl 對象并通過 Activity 的 attach 方法來完成一些重要數(shù)據(jù)的初始化。見 createBaseContextForActivity 的實(shí)現(xiàn)。
ContextImpl 是 Context 的具體實(shí)現(xiàn)。ContextImpl 是通過 Activity 的 attach 方法和 Activity 建立關(guān)聯(lián)的。這樣當(dāng) Window 接收到外部輸入事件后就可以將時間傳遞給 Activity。具體看 attach 實(shí)現(xiàn)。

第五段：

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

mInstrumentation.callActivityOnCreate 調(diào)用 Activity 的 onCreate 方法。由于 onCreate 已經(jīng)被調(diào)用，這意味著 Activity 已經(jīng)完成了整個啟動過程。

參考資料：《藝術(shù)探索》

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容