我們來看一下Activity啟動流程，當(dāng) A 調(diào)用 startActivity(intent); 啟動 B 的時候，系統(tǒng)是如何幫我們打開一個新的Activity的？
下面我們來從源碼分析(Api : 25)：

1、首先我們來到Activity類中

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

    @Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            startActivityForResult(intent, -1);
        }
    }

    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                // 關(guān)鍵是調(diào)用這句代碼
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            // ...
        } else {
            // ...
        }
    }

執(zhí)行 mInstrumentation.execStartActivity方法，我們找到 mInstrumentation 為 Instrumentation這個類
2、我們現(xiàn)在來到Instrumentation類中

    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        // ...
        
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            // 關(guān)鍵調(diào)用了這句代碼
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

這里 ActivityManagerNative.getDefault() 返回的是一個 IActivityManager 接口，并且 ActivityManagerNative是實現(xiàn) IActivityManager 接口的
3、我們來到 ActivityManagerNative類中

    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 {
        // 典型的IPC機制，這里保存了一些數(shù)據(jù)
        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);
        }
        // IPC機制，發(fā)送一個消息，我們直接在本類中來搜 START_ACTIVITY_TRANSACTION，搜索服務(wù)端的代碼
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

    @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        // 這里就是我們搜索到服務(wù)端代碼入口
        case START_ACTIVITY_TRANSACTION:
        {
            // 接收客戶端傳來的消息
            data.enforceInterface(IActivityManager.descriptor);
            IBinder b = data.readStrongBinder();
            IApplicationThread app = ApplicationThreadNative.asInterface(b);
            String callingPackage = data.readString();
            Intent intent = Intent.CREATOR.createFromParcel(data);
            String resolvedType = data.readString();
            IBinder resultTo = data.readStrongBinder();
            String resultWho = data.readString();
            int requestCode = data.readInt();
            int startFlags = data.readInt();
            ProfilerInfo profilerInfo = data.readInt() != 0
                    ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
            Bundle options = data.readInt() != 0
                    ? Bundle.CREATOR.createFromParcel(data) : null;
            // 啟動Activity，ActivityManagerNative是一個抽象類的，所以這里調(diào)用ActivityManagerService中的startActivity
            int result = startActivity(app, callingPackage, intent, resolvedType,
                    resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
            reply.writeNoException();
            reply.writeInt(result);
            return true;
        }
        // ...
    }

4、我們來到 ActivityManagerService 類中

    @Override
    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
    }


    @Override
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
        // 這里調(diào)用ActivityStarter類中的startActivityMayWait
        return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, bOptions, false, userId, null, null);
    }

5、我們來到 ActivityStarter 類中

    final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, IActivityManager.WaitResult outResult, Configuration config,
            Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask) {
        // ...
        int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                    inTask);
        // ...
        return res;
    }


    final int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask) {
        // ...
        int err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                    true, options, inTask);
        return err;
    }


    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {
        // ...
        
        // mSupervisor: ActivityStackSupervisor 
        mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                        mOptions);
        
        // ...
        return START_SUCCESS;
    }

6、我們來到 ActivityStackSupervisor 類中

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
            // targetStack : ActivityStack
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        // ...
        return false;
    }

7、我們來到 ActivityStack 類中

    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        // ...
        boolean result = false;
        try {
            // ...
            // 關(guān)鍵調(diào)用這句代碼
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        // ...
        
        if (mResumedActivity != null) {
            // 此處就會調(diào)用暫停方法
            pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
        }
        
        //mStackSupervisor ： ActivityStackSupervisor，這里就會調(diào)用新建方法
        mStackSupervisor.startSpecificActivityLocked(next, true, true);
        
        return true;
    }

    final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
            ActivityRecord resuming, boolean dontWait) {
         // ...
         // prev.app.thread為 ActivityThread 
         prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, dontWait);
         // ...
         return true;
    }

8、我們先來看暫停的方法，我們來到 ActivityThread 類中

    public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
            int seq = getLifecycleSeq();
            // 發(fā)送了一個消息，消息key： PAUSE_ACTIVITY，我們來搜這個key
            sendMessage(
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
                    configChanges,
                    seq);
        }

        case PAUSE_ACTIVITY: {
                    // 關(guān)鍵調(diào)用方法
                    handlePauseActivity((IBinder) args.arg1, false,
                            (args.argi1 & USER_LEAVING) != 0, args.argi2,
                            (args.argi1 & DONT_REPORT) != 0, args.argi3);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

     private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport, int seq) {
         
         // ...
         performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
         
         // ...
    }

    final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState, String reason) {
        // ...
        performPauseActivityIfNeeded(r, reason);
        // ...
        return !r.activity.mFinished && saveState ? r.state : null;
    }

    private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
        // ...
        // mInstrumentation: Instrumentation
        mInstrumentation.callActivityOnPause(r.activity);
        // ...
    }

9、我們來到Instrumentation類中：

    public void callActivityOnPause(Activity activity) {
        activity.performPause();
    }

10、我們來到Activity類中

    final void performPause() {
        // ...
        // 終于看到了一個我們比較熟悉的方法，到這里調(diào)用了A的暫停方法
        onPause();
        // ...
        mResumed = false; 
    }

11、還記得我們在第7步中還有一個方法沒走嘛？ 現(xiàn)在我們回到 第7步中的ActivityStack 的resumeTopActivityInnerLocked方法中，在暫停方法下面還有一個新建方法：mStackSupervisor.startSpecificActivityLocked(next, true, true);
我們來到ActivityStackSupervisor類中

    void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // ... 
        // 關(guān)鍵代碼
        realStartActivityLocked(r, app, andResume, checkConfig);
        // ... 
    }

    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
        // ... 
        // 關(guān)鍵代碼，app.thread：ActivityThread 
        app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
        // ... 
        return true;
    }

12、我們再次來到 ActivityThread 類中

        @Override
        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) {

            
            // ...
            // 關(guān)鍵代碼，發(fā)送一個消息，消息key為 LAUNCH_ACTIVITY，我們來搜 LAUNCH_ACTIVITY
            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

        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);
                    // 關(guān)鍵代碼
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        // ...
        
        // 關(guān)鍵代碼
        Activity a = performLaunchActivity(r, customIntent);
        
        if (a != null) {
            // ...
            // 關(guān)鍵代碼
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
        }
        
        // 關(guān)鍵代碼
        Looper.myQueue().addIdleHandler(new Idler());
    }

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

        return activity;
    }

13、我們再次來到Instrumentation類中：

    public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

14、我們再次來到Activity類中

    final void performCreate(Bundle icicle) {
        restoreHasCurrentPermissionRequest(icicle);
        // 終于看到了我們的onCreate方法
        onCreate(icicle);
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

15、我們再次回到12 的 ActivityThread的handleLaunchActivity方法中，繼續(xù)執(zhí)行handleResumeActivity方法

    final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        r = performResumeActivity(token, clearHide, reason);
    }

    public final ActivityClientRecord performResumeActivity(IBinder token,
            boolean clearHide, String reason) {
        // ...
        r.activity.performResume();
        return r;
    }

16、我們再次來到Activity類中

    final void performResume() {
        // ...
        performRestart();
        // ...
        // mInstrumentation: Instrumentation
        mInstrumentation.callActivityOnResume(this);
    }

    final void performRestart() {
        performStart();
    }

    final void performStart() {
        // mInstrumentation: Instrumentation
        mInstrumentation.callActivityOnStart(this);
    }

17、我們再次來到Instrumentation類中：

    public void callActivityOnStart(Activity activity) {
        // 在這里看到了我們的onStart方法
        activity.onStart();
    }

    public void callActivityOnResume(Activity activity) {
        // 在這里看到了我們的onResume方法
        activity.onResume();
    }

18、我們再次回到12 的 ActivityThread的handleLaunchActivity方法中，繼續(xù)執(zhí)行Looper.myQueue().addIdleHandler(new Idler());方法

    private class Idler implements MessageQueue.IdleHandler {
        @Override
        public final boolean queueIdle() {
            // ...
            // 這里的am就是ActivityManagerService 
            IActivityManager am = ActivityManagerNative.getDefault();
            am.activityIdle(a.token, a.createdConfig, stopProfiling);
            // ...
        }
    }

19、我們再次來到ActivityManagerService 類中：

    @Override
    public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
        // ...
        // 這里的mStackSupervisor：ActivityStackSupervisor
        ActivityRecord r = mStackSupervisor.activityIdleInternalLocked(token, false, config);
        // ...
    }

20、我們再次來到 ActivityStackSupervisor 類中：

    final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
            Configuration config) {
        // ...
        // 這里的stack： ActivityStack
        stack.stopActivityLocked(r);
        // ...
        return r;
    }

21、我們來到 ActivityStack 類中

    final void stopActivityLocked(ActivityRecord r) {
        r.app.thread.scheduleStopActivity(r.appToken, r.visible, r.configChangeFlags);
    }

22、我們再次來到ActivityThread類中

    public final void scheduleStopActivity(IBinder token, boolean showWindow,
                int configChanges) {
            int seq = getLifecycleSeq();
            if (DEBUG_ORDER) Slog.d(TAG, "stopActivity " + ActivityThread.this
                    + " operation received seq: " + seq);
            sendMessage(
                // 發(fā)送一個消息STOP_ACTIVITY_SHOW，我們來搜這個STOP_ACTIVITY_SHOW
                showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
                token, 0, configChanges, seq);
     }

    case STOP_ACTIVITY_SHOW: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
                    SomeArgs args = (SomeArgs) msg.obj;
                    // 關(guān)鍵方法
                    handleStopActivity((IBinder) args.arg1, true, args.argi2, args.argi3);
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

    private void handleStopActivity(IBinder token, boolean show, int configChanges, int seq) {
        // 關(guān)鍵方法
        performStopActivityInner(r, info, show, true, "handleStopActivity");
    }

    private void performStopActivityInner(ActivityClientRecord r,
            StopInfo info, boolean keepShown, boolean saveState, String reason) {
        
        r.activity.performStop(false /*preserveWindow*/);
    }

23、我們再次來到Activity類中

    final void performStop(boolean preserveWindow) {
            mInstrumentation.callActivityOnStop(this);
    }

24、我們再次來到Instrumentation類中：

    public void callActivityOnStop(Activity activity) {
        activity.onStop();
    }

總結(jié)：

A啟動B方法順序： A的onPause -> B的onCreate -> B的onStart方法 -> B的onResume -> A的onStop