前言：眾所周知，Activity是四大組件之首，網(wǎng)上關(guān)于Activity的博客也有很多，相信大家對于他的生命周期和啟動模式有了相應(yīng)的了解。本文就不再對這些進行講述了，我要從源碼的角度對一個Activity的啟動過程進行分析。

我們知道，當startActivity被調(diào)用的時候，可以啟動一個Activity，但是你知道這個Activity是如何被啟動的嗎？你知道這個Activity是啥時候被創(chuàng)建的嗎？為什么onCreate是Activity的執(zhí)行入口呢？所有的這一切都被系統(tǒng)封裝好了，對我們來說是透明的，我們使用的時候僅僅是傳遞一個intent然后startActivity就可以達到目的了，不用擔心，閱讀了本文以后，你將會了解它的背后到底做了哪些事情。在分析之前，我先介紹幾個類：

Activity：startActivity方法的真正實現(xiàn)在Activity中
Instrumentation：用來輔助Activity完成啟動Activity的過程
ActivityThread（包含ApplicationThread + ApplicationThreadNative + IApplicationThread）：真正啟動Activity的實現(xiàn)都在這里

開始源碼分析：Activity#startActivity()

public void startActivity(Intent intent) {
    this.startActivity(intent, null);
}

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

public void startActivityForResult(Intent intent, int requestCode) {
    startActivityForResult(intent, requestCode, null);
}

從上面的代碼中我們發(fā)現(xiàn)：調(diào)用startActivty實際上最后還是調(diào)用了startActivityForResult 方法。那么，我們沿著這個方法繼續(xù)深入探討：
Activity#startActivityForResult

public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
    if (mParent == null) {
      //真正執(zhí)行啟動activity的代碼邏輯
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, this,
                intent, requestCode, options);
        //啟動activity返回的結(jié)果處理
        if (ar != null) {
            mMainThread.sendActivityResult(
                mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                ar.getResultData());
        }
        if (requestCode >= 0) {
     
             mStartedActivity = true;
        }

        cancelInputsAndStartExitTransition(options);
        // TODO Consider clearing/flushing other event sources and events for child windows.
    } else {
        if (options != null) {
            mParent.startActivityFromChild(this, intent, requestCode, options);
        } else {
            // Note we want to go through this method for compatibility with
            // existing applications that may have overridden it.
            mParent.startActivityFromChild(this, intent, requestCode);
        }
    }
}

從上面代碼我們發(fā)現(xiàn)，實際上調(diào)用的啟動activity方法的還是Instrumentation類。也就是我們第二個要研究的重點類。
Instrumentation#execStartActivity

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
   //這個whoThread執(zhí)行了啟動activity
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    Uri referrer = target != null ? target.onProvideReferrer() : null;
    if (referrer != null) {
        intent.putExtra(Intent.EXTRA_REFERRER, referrer);
    }
    if (mActivityMonitors != null) {
        synchronized (mSync) {
            final int N = mActivityMonitors.size();
          //遍歷一遍，查詢是否存在這個activity，activity類存放在intent中。
            for (int i = 0; i < N; i++) {
                final ActivityMonitor am = mActivityMonitors.get(i);
                if (am.match(who, null, intent)) {
                    am.mHits++;
                    if (am.isBlocking()) {
                        return requestCode >= 0 ? am.getResult() : null;
                    }
                    break;
                }
            }
        }
    }
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess();
        //這里通過ActivityManager啟動了activity
        int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
        //檢查啟動activity返回的結(jié)果
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

從上面，相關(guān)代碼我都加上了注釋。有兩點：
1：真正執(zhí)行activity的啟動過程的是ActivityManagerNative.getDefault().startActivity。
2：執(zhí)行啟動activity之后，有一個代碼檢查結(jié)果。
我們先看看第2個方法：
Instrumentation#checkStartActivityResult

public static void checkStartActivityResult(int res, Object intent) {
    if (res >= ActivityManager.START_SUCCESS) {
        return;
    }

    switch (res) {
        case ActivityManager.START_INTENT_NOT_RESOLVED:
        case ActivityManager.START_CLASS_NOT_FOUND:
            if (intent instanceof Intent && ((Intent) intent).getComponent() != null)
                throw new ActivityNotFoundException(
                        "Unable to find explicit activity class "
                                + ((Intent) intent).getComponent().toShortString()
                                + "; have you declared this activity in your AndroidManifest.xml?");
            throw new ActivityNotFoundException(
                    "No Activity found to handle " + intent);
        case ActivityManager.START_PERMISSION_DENIED:
            throw new SecurityException("Not allowed to start activity "
                    + intent);
        case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
            throw new AndroidRuntimeException(
                    "FORWARD_RESULT_FLAG used while also requesting a result");
        case ActivityManager.START_NOT_ACTIVITY:
            throw new IllegalArgumentException(
                    "PendingIntent is not an activity");
        case ActivityManager.START_NOT_VOICE_COMPATIBLE:
            throw new SecurityException(
                    "Starting under voice control not allowed for: " + intent);
        case ActivityManager.START_NOT_CURRENT_USER_ACTIVITY:
            // Fail silently for this case so we don't break current apps.
            // TODO(b/22929608): Instead of failing silently or throwing an exception,
            // we should properly position the activity in the stack (i.e. behind all current
            // user activity/task) and not change the positioning of stacks.
            Log.e(TAG,
                    "Not allowed to start background user activity that shouldn't be displayed"
                            + " for all users. Failing silently...");
            break;
        default:
            throw new AndroidRuntimeException("Unknown error code "
                    + res + " when starting " + intent);
    }
}

有沒有一些熟悉的異常信息呢？比如：如果我們沒有在xml配置文件中注冊activity，那么啟動activity的時候是不是會報Unable to find explicit activity class......。

那么，我們回到第1個問題，真正執(zhí)行的啟動代碼在
ActivityManagerNative.getDefault().startActivity()中:
我們發(fā)現(xiàn)：ActivityManagerNative是抽象類，getDefault() 方法返回的是IActivityManager，也僅僅是一個接口而已；那么實際上我們跟蹤代碼會發(fā)現(xiàn)startActivity()也僅僅是IActivityManager的一個方法而已，那么我們是不是到這里就束手無策了呢？
答案當然是否定的。
1：我們找到IApplicationThread的接口截圖：

IApplicationThread.png

我們可以發(fā)現(xiàn)很多類似activity生命周期的方法，onCreate，onStart，onResume等等。是不是明白了什么呢？是的，activity的生命周期實際上是在調(diào)用這些方法，但是這只是一個接口，我們需要繼續(xù)找到他的實現(xiàn)類。別急，下面會講到；

2：我們需要找到IActivityManager的實現(xiàn)類。
那么，我們來看看IActivityManager#startActivity()方法：ActivityManagerNative抽象類，這個抽象類使用了代理

  class ActivityManagerProxy implements IActivityManager；
//這個代理類實現(xiàn)了IActivityManager的startActivity方法，我們看看：
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
        String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken(IActivityManager.descriptor);
    data.writeStrongBinder(caller != null ? caller.asBinder() : null);
    data.writeString(callingPackage);
    intent.writeToParcel(data, 0);
    data.writeString(resolvedType);
    data.writeStrongBinder(resultTo);
    data.writeString(resultWho);
    data.writeInt(requestCode);
    data.writeInt(startFlags);
    if (profilerInfo != null) {
        data.writeInt(1);
        profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
    } else {
        data.writeInt(0);
    }
    if (options != null) {
        data.writeInt(1);
        options.writeToParcel(data, 0);
    } else {
        data.writeInt(0);
    }
  //上面都是一些數(shù)據(jù)的填寫，這里是智行事務(wù)的邏輯代碼
    mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
    reply.readException();
    int result = reply.readInt();
    reply.recycle();
    data.recycle();
    return result;
}
private IBinder mRemote;

我們從代碼發(fā)現(xiàn)了mRemote是一個IBinder，調(diào)用了IBinder的transact()方法，真是IBinder無處不在啊。這說明了啟動Activity實際上也是進行了進程間的通信。是不是又明白了什么？比如A應(yīng)用要啟動B應(yīng)用的某個Activity，怎么做？進程間通信幫你解決。偉大的IBinder，如果你們需要的話，后期我會出一個IBinder機制講解，可以通過源碼分析，因為我個人認為，結(jié)合源碼分析會更加有說服力并使得自己記憶更加牢固。（有這樣需求的請留言讓我看到哦...）

那么mRemote的初始化問題大家應(yīng)該都清楚吧，上面我們調(diào)用了ActivityManagerNative.getDefault()，代碼我就不貼出來了，使用了單利模式，大家可以進去看看。

我們從上面知道了IApplicationThread執(zhí)行了啟動activity，那么誰實現(xiàn)了該接口呢？當然是ApplicationThread，這個類是ActivityThread的內(nèi)部類。里面很多的方法都對應(yīng)了相關(guān)的activity生命周期方法，我們僅僅來看看scheduleLaunchActivity：

public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
            ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
            CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
            int procState, Bundle state, PersistableBundle persistentState,
            List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
            boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

        updateProcessState(procState, false);

        ActivityClientRecord r = new ActivityClientRecord();

        r.token = token;
        r.ident = ident;
        r.intent = intent;
        r.referrer = referrer;
        r.voiceInteractor = voiceInteractor;
        r.activityInfo = info;
        r.compatInfo = compatInfo;
        r.state = state;
        r.persistentState = persistentState;

        r.pendingResults = pendingResults;
        r.pendingIntents = pendingNewIntents;

        r.startsNotResumed = notResumed;
        r.isForward = isForward;

        r.profilerInfo = profilerInfo;

        r.overrideConfig = overrideConfig;
        updatePendingConfiguration(curConfig);

        sendMessage(H.LAUNCH_ACTIVITY, r);
    }

我們看到最后的sendMessage，往下走我們找到H類的處理消息方法

public void handleMessage(Message msg) {
        if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
        switch (msg.what) {
            case LAUNCH_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                r.packageInfo = getPackageInfoNoCheck(
                        r.activityInfo.applicationInfo, r.compatInfo);
                handleLaunchActivity(r, null);
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            } break; ....

代碼沒有全部貼出，僅僅是看看LAUNCH_ACTIVITY 的處理即可。我們可以看到handleLaunchActivity(),沿著這個方法繼續(xù)往下尋找，最后發(fā)現(xiàn)performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ActivityInfo aInfo = r.activityInfo;
    ComponentName component = r.intent.getComponent();
    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);
        }
    }
        ......
    return activity;
}

最后的邏輯都在這里，通過我們的intent數(shù)據(jù)，結(jié)合classLoader找到了相關(guān)的類并且加載進來了。詳細的邏輯在這里就不講太多了。

其實我們了解看源代碼并不需要了解各種細節(jié)，只是需要了解他的框架即可。如果你深入了解了細節(jié)，恐怕會發(fā)生鉆牛角尖的情況。這樣對于整體的把握可能會不好。當然，如果你是做ROM開發(fā)或者個人已經(jīng)掌握了Android源碼框架，深入研究未嘗不可。