Activity啓動流程(基於Android10附關鍵代碼及流程圖)

我們在平常開發的過程中，想啓動一個Activity怎麼辦？startActivity(Intent intent)就可以了，這是一個簡單得不能在簡單的問題了。但如果問你啓動一個Activity具體經過了哪些步驟，即時在同一App內調用startActivity是否用到了進程間通信呢？是不是有點蒙，我一個App內啓動一個Activity還會用到進程間通信，要搞基(什麼)？那麼，我們就具體來看一看吧，也許這種知識在99%的開發中我們都不可能會用到，但多瞭解一些對我們也沒什麼壞處吧。
先上一張啓動調用圖吧，有點亂，將就看吧。誰讓俺們對畫這種圖不專業呢。

毫無疑問，不管你是繼承的什麼Activity，啓動都是從startActivity開始
Activity類

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);
        }
    }
//調用到startActivityForResult
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
    }
//又調用了重載的startActivityForResult
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options){
            //關鍵代碼
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            }

調用mInstrumentation.execStartActivity這時候進入到了Instrumentation類
Instrumentation類

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options){
            //關鍵代碼
     int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
}

看下ActivityTaskManager類 調用getService的內容如下

public static IActivityTaskManager getService() {
        return IActivityTaskManagerSingleton.get();
    }
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
            new Singleton<IActivityTaskManager>() {
                @Override
                protected IActivityTaskManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                    return IActivityTaskManager.Stub.asInterface(b);
                }
            };

注意看IActivityTaskManagerSingleton裏面實例的時候得到的是IBinder，是否似曾相識？AIDL用過沒？一模一樣的用法。注意，這時候開始我們進入系統的進程，已經不在本進程了哈。正式登陸火星。

public class ActivityTaskManagerService extends IActivityTaskManager.Stub

這裏貼出這個類的關係主要是表明ActivityTaskManagerService就是IActivityTaskManager.Stub
這時候我們有得進到ActivityTaskManagerService這個類了，找startActivity這個方法

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());
    }
//調用startActivityAsUser
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
                true /*validateIncomingUser*/);
    }
 //調用重載方法startActivityAsUser
int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
            boolean validateIncomingUser){
            //關鍵代碼
     return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();
 }

obtainStarter返回一個ActivityStarter類實例，注意下setMayWait這個，對我們後續流程分支有影響。
ActivityStarter類

//setMayWait將mayWait設置爲了true
ActivityStarter setMayWait(int userId) {
        mRequest.mayWait = true;
        mRequest.userId = userId;

        return this;
    }
int execute() {
        try {
			//setMayWait決定了我們將走if分支  參數多得一匹
            if (mRequest.mayWait) {
                return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                        mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
                        mRequest.intent, mRequest.resolvedType,
                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                        mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                        mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                        mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                        mRequest.inTask, mRequest.reason,
                        mRequest.allowPendingRemoteAnimationRegistryLookup,
                        mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
            } else {
                //
        } finally {
            onExecutionComplete();
        }
    }
private int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
            Intent intent, String resolvedType, IVoiceInteractionSession voiceSession,
            IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, WaitResult outResult,
            Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
            int userId, TaskRecord inTask, String reason,
            boolean allowPendingRemoteAnimationRegistryLookup,
            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart){
            //關鍵代碼
     int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
                    voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
                    ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
                    allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
                    allowBackgroundActivityStart);
 }
 //進入到這個方法
 private int startActivity(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,
            SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, TaskRecord inTask, String reason,
            boolean allowPendingRemoteAnimationRegistryLookup,
            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart){
      //關鍵代碼
      mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
                aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
                callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
                inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
                allowBackgroundActivityStart);
 }
 //進入這個重載方法
 private int startActivity(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,
            SafeActivityOptions options,
            boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
            TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup,
            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart){
      //關鍵代碼
      final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
 }
 //又進入了這個重載，好吧，我承認我有點暈車
 private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                ActivityRecord[] outActivity, boolean restrictedBgActivity){
     //關鍵代碼
     result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
}
//調用startActivityUnchecked
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity, boolean restrictedBgActivity){
       //關鍵代碼
       if (dontStart) {
         	//非常關鍵  前面我們都會找到startActivity系列，但這裏需要從這裏走，不然會迷路的
            if (mDoResume) {
                mRootActivityContainer.resumeFocusedStacksTopActivities();
            }
      }
 }

進入RootActivityContainer類

boolean resumeFocusedStacksTopActivities() {
        return resumeFocusedStacksTopActivities(null, null, null);
    }
//調用重載方法
boolean resumeFocusedStacksTopActivities(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions){
     //關鍵代碼
     if (targetStack != null && (targetStack.isTopStackOnDisplay()
                || getTopDisplayFocusedStack() == targetStack)) {
            result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
}

targetStack是ActivityStack類的實例，所以進入ActivityStack類了

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options){
	//關鍵代碼
	try {
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mInResumeTopActivity = false;
        }
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options){
	//關鍵代碼
	mStackSupervisor.startSpecificActivityLocked(next, true, true);
}

進入ActivityStackSupervisor類

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig){
	//關鍵代碼
	try {
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }
}
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException{
      //關鍵代碼
      // Schedule transaction.
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);
 }

mService是ActivityTaskManagerService的實例 getLifecycleManager

ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }

返回的是ClientLifecycleManager
進入ClientLifecycleManager

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        //關鍵代碼
        transaction.schedule();
        if (!(client instanceof Binder)) {
            // If client is not an instance of Binder - it's a remote call and at this point it is
            // safe to recycle the object. All objects used for local calls will be recycled after
            // the transaction is executed on client in ActivityThread.
            transaction.recycle();
        }
    }

transation是ClientTransation的實例，進入到了ClientTransaction類

public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

看下mClient的定義

private IApplicationThread mClient;

是不是瞬間千萬匹飄過，點不進去了啊。莫慌，他明顯是一個接口類，而且前面我們不是看到了AIDL麼，感覺是不是要讓我們回地球的感覺了呢？
其實現類在ActivityThread類的一個內部類ApplicationThread，看下這個類吧

private class ApplicationThread extends IApplicationThread.Stub 

嗯嗯，又給續上了。而且成功讓我們從火星迴到了地球(我們的APP進程)

public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }

嗯，這裏面就一句代碼，調用了 ActivityThread.this.scheduleTransaction(transaction);
其調用了父類ClientTransactionHandler的

void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

發送了消息而且也明確給我們了在ActivityThread.H類裏面
在H類裏面進行了處理

case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    //關鍵代碼
                    mTransactionExecutor.execute(transaction);
                    if (isSystem()) {
                        transaction.recycle();
                    }
                    break;

mTransactionExecutor是什麼呢？

private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);

這是定義在ActivityThread類裏的，並傳入this進行的實例。這點非常關鍵
進入到TransactionExecutor類

public void execute(ClientTransaction transaction){
	//關鍵代碼
	executeCallbacks(transaction);
}
public void executeCallbacks(ClientTransaction transaction){
	//關鍵代碼
	final ClientTransactionItem item = callbacks.get(i);
	item.execute(mTransactionHandler, token, mPendingActions);
}

item是ClientTransactionItem的實例

public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {
    /** Get the state that must follow this callback. */
    @LifecycleState
    public int getPostExecutionState() {
        return UNDEFINED;
    }
    @Override
    public int describeContents() {
        return 0;
    }
}

但是ClientTransactionItem這個也太抽象了吧，沒有任何我們需要的信息啊
那麼只能從callbacks那入手了，嗯，這部份得追溯到前面很遠的代碼，直接上結果吧

public class LaunchActivityItem extends ClientTransactionItem

這裏的item其實就是LaunchActivityItem這個類

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, mAssistToken);
         //關鍵是這句
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

client是ClientTransactionHandler 的實例，這裏傳過來的其實就是ActivityThread這個類對象實例

public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent){
     //關鍵代碼
     final Activity a = performLaunchActivity(r, customIntent);
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent){
	//關鍵代碼
	//創建Activity實例
	activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
    //OnCreate
    if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
}

嗯，又調到了Instrumentation這個類了

public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        //這句是關鍵
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }

成功拉回了我們最熟悉的Activity類

final void performCreate(Bundle icicle) {
        performCreate(icicle, null);
    }
//調用重載類
final void performCreate(Bundle icicle, PersistableBundle persistentState){
	//關鍵代碼
	if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
}
//在調用我們最最熟悉的onCreate
protected void onCreate(@Nullable Bundle savedInstanceState){
}

哈哈，雖然很懵，但還算是將整個流程走完了。整個流程只看了我們所希望的關鍵代碼，也沒有去理解其中代碼的含義(確實太火星了，理解不了啊)，但也對我們瞭解Activity的整個啓動流程以及啓動過程中所調用的關鍵類還是有所瞭解的。而且看完之後我們也知道了哪怕是在APP內啓動Activity其實也是通過AIDL通過系統級來完成的。
其實平時我們所調用的一個看似簡單的API，其內部流程還是那麼的複雜，只嘆自己太LOW吧!