Android原始碼分析-Android9.0下的Activity啟動流程

摘要： 前言 最近在閱讀Android原始碼時，發現最新的Android9.0原始碼中startActivity啟動Activity的流程相比於低版本的Android原始碼來說改動較大，且本人在網上也沒有找到基於Android9.0的相關原始碼分析文章。故寫下此文，記錄下原始碼追蹤流程，方便以後自...

前言

最近在閱讀Android原始碼時，發現最新的Android9.0原始碼中startActivity啟動Activity的流程相比於低版本的Android原始碼來說改動較大，且本人在網上也沒有找到基於Android9.0的相關原始碼分析文章。故寫下此文，記錄下原始碼追蹤流程，方便以後自己複查，同時也分享給有需要的讀者。

Activity->startActivity

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

Activity->startActivityForResult

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
// mParent指的是Activity 賦值是在內部API呼叫setParent方法
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
//Instrumentation為工具類ActivityResult為其靜態內部類工具類呼叫執行開始Activity方法execStartActity
//mMainThread為ActivityThread ，getApplicationThread()方法獲取的是ApplicationThread例項
//ApplicationThread是ActivityThread的內部類該類繼承ApplicationThreadNative抽象類，
//而ApplicationThreadNative繼承Binder類並實現IApplicationThread介面
//IApplictionThread繼承了IInterface介面
//Binder類繼承IBinder介面，這就是為什麼execStartActivity方法的第二個引數定義為IBinder
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
// ar不為空說明Activity啟動成功
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
mStartedActivity = true;
}

cancelInputsAndStartExitTransition(options);
} 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);
}
}
}

呼叫了mInstrumentation.execStartActivity方法

Instrumentation->execStartActivity

public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
//ActivityMonitor為Activity的監測器是Instrumentation的靜態內部類，
//當一個Activity啟動時將會被檢測
final ActivityMonitor am = mActivityMonitors.get(i);
ActivityResult result = null;
if (am.ignoreMatchingSpecificIntents()) {
result = am.onStartActivity(intent);
}
if (result != null) {
am.mHits++;
return result;
} else if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
// result 為啟動Activity返回的狀態碼
// 這裡通過IPC機制，呼叫了ActivityManagerService中的startActivity方法
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
//檢查Activity是否啟動成功若未啟動成功則丟擲對應異常
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}

可以看到，這個方法最後是呼叫了ActivityManager.getService().startActivity()方法。

檢視ActivityManager原始碼

ActivityManager->getService

public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}

private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
// 通過Binder機制獲取ActivityManagerService
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};

這裡是通過Binder的跨程序通訊獲取到了系統服務ActivityManagerService，所以ActivityManager.getService().startActivity()是呼叫了ActivityManagerService中的startActivity方法。

ActivityManagerService->startActivity

@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) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}

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,
boolean validateIncomingUser) {
enforceNotIsolatedCaller("startActivity");

userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

// TODO: Switch to user app stacks here.
// 通過mActivityStartController獲取ActivityStarter，進行後續頁面跳轉
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
.execute();
}

這裡最後通過mActivityStartController.obtainStarter獲取到了一個ActivityStarter物件，然後設定了一些屬性，最後呼叫了execute()方法。所以流程走到ActivityStarter中的execute()方法。

ActivityStarter->execute

int execute() {
try {
// TODO(b/64750076): Look into passing request directly to these methods to allow
// for transactional diffs and preprocessing.
// ActivityManagerService中的startActivityAsUser方法中呼叫了setMayWait方法
// setMayWait方法會將mRequest.mayWait置為true，所以這裡會走startActivityMayWait方法
//ActivityStarter setMayWait(int userId) {
//mRequest.mayWait = true;
//mRequest.userId = userId;
//
//return this;
//}
if (mRequest.mayWait) {
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, 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);
} else {
return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
mRequest.outActivity, mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
}
} finally {
onExecutionComplete();
}
}

檢視setMayWait方法

ActivityStarter setMayWait(int userId) {
mRequest.mayWait = true;
mRequest.userId = userId;

return this;
}

ActivityManagerService中的startActivityAsUser方法中呼叫了setMayWait方法。setMayWait方法會將mRequest.mayWait置為true，所以這裡會走startActivityMayWait方法

ActivityStarter->startActivityMayWait

private 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, WaitResult outResult,
Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
int userId, TaskRecord inTask, String reason,
boolean allowPendingRemoteAnimationRegistryLookup) {

...略

// Collect information about the target of the Intent.
// 對Intent引數進行解析獲取Activity的相關資訊，並把資料儲存在aInfo變數中
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
synchronized (mService) {

...略

final ActivityRecord[] outRecord = new ActivityRecord[1];
// 呼叫ActivityStarter的startActivity方法
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);

....略

//通知跟蹤器Activity正在啟動
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
return res;
}
}

呼叫ActivityStarter的startActivity方法

ActivityStarter->startActivity

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

...一些必要的判斷...

// 檢查是否有開啟新Activity的許可權
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
inTask != null, callerApp, resultRecord, resultStack);
abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
callingPid, resolvedType, aInfo.applicationInfo);

...

// 如果我們開始的活動與當前恢復的活動的UID不同，檢查是否允許應用程式切換。
if (voiceSession == null && (stack.getResumedActivity() == null
|| stack.getResumedActivity().info.applicationInfo.uid != realCallingUid)) {
if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
realCallingPid, realCallingUid, "Activity start")) {
mController.addPendingActivityLaunch(new PendingActivityLaunch(r,
sourceRecord, startFlags, stack, callerApp));
ActivityOptions.abort(checkedOptions);
return ActivityManager.START_SWITCHES_CANCELED;
}
}

// 載入PendingActivity
mController.doPendingActivityLaunches(false);

// 繼續呼叫方法
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity);
}

繼續呼叫同名方法startActivity

ActivityStarter->startActivity

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
int result = START_CANCELED;
try {
mService.mWindowManager.deferSurfaceLayout();
// 呼叫startActivityUnchecked方法，返回結果
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity);
} finally {
// 如果我們無法繼續，請解除活動與任務的關聯。使活動處於不完整狀態可能會導致問題，例如在沒有視窗容器的情況下執行操作。
final ActivityStack stack = mStartActivity.getStack();
if (!ActivityManager.isStartResultSuccessful(result) && stack != null) {
stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
null /* intentResultData */, "startActivity", true /* oomAdj */);
}
mService.mWindowManager.continueSurfaceLayout();
}

postStartActivityProcessing(r, result, mTargetStack);

return result;
}

呼叫startActivityUnchecked方法

ActivityStarter->startActivityUnchecked

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {

// 初始化ActivityStarter全域性變數
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor);

computeLaunchingTaskFlags();

computeSourceStack();

mIntent.setFlags(mLaunchFlags);

// 判斷是否應將新Activity插入到現有任務棧中
// 如果不需要，則返回null，如果需要，則返回該任務棧資訊
ActivityRecord reusedActivity = getReusableIntentActivity();

......

// 使新Activity可見
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
mService.mWindowManager.executeAppTransition();
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
// 關注這裡
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
} else if (mStartActivity != null) {
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
}
mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);

mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode,
preferredLaunchDisplayId, mTargetStack);

return START_SUCCESS;
}

這裡需要關注的是mSupervisor.resumeFocusedStackTopActivityLocked方法

ActivityStackSupervisor->resumeFocusedStackTopActivityLocked

boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {

if (!readyToResume()) {
return false;
}

if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}

final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || !r.isState(RESUMED)) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.isState(RESUMED)) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}

return false;
}

可以看到，這裡呼叫了resumeTopActivityUncheckedLocked方法

ActivityStackSupervisor->resumeTopActivityUncheckedLocked

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mStackSupervisor.inResumeTopActivity) {
// Don't even start recursing.
return false;
}

boolean result = false;
try {
// Protect against recursion.
mStackSupervisor.inResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);

// When resuming the top activity, it may be necessary to pause the top activity (for
// example, returning to the lock screen. We suppress the normal pause logic in
// {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
// end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
// to ensure any necessary pause logic occurs. In the case where the Activity will be
// shown regardless of the lock screen, the call to
// {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mStackSupervisor.inResumeTopActivity = false;
}

return result;
}

這裡呼叫了resumeTopActivityInnerLocked方法，resumeTopActivityInnerLocked方法中會呼叫startSpecificActivityLocked方法，然後再呼叫realStartActivityLocked方法。Activity的啟動事務就是在realStartActivityLocked方法中啟動的。

ActivityStackSupervisor->realStartActivityLocked

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {

......

try {

......

// Create activity launch transaction.
// 建立Activity啟動事務
// ClientTransaction.obtain方法如下：
// public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
//ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
//if (instance == null) {
//instance = new ClientTransaction();
//}
//instance.mClient = client;
//instance.mActivityToken = activityToken;
//
//return instance;
// }
// 這裡傳入的app.thread會賦值給ClientTransaction的成員變數mClient，
// 而ClientTransaction會呼叫mClient.scheduleTransaction(this)來執行事務
// 所以事務最終是呼叫app.thread的scheduleTransaction執行。
// 而這個app.thread是ActivityThread的內部類ApplicationThread。
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));

// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);

// Schedule transaction.
// 執行Activity啟動事務
mService.getLifecycleManager().scheduleTransaction(clientTransaction);

......

} catch (RemoteException e) {
if (r.launchFailed) {
// 第二次啟動失敗的異常處理
return false;
}

// 第一次啟動失敗，重試
r.launchFailed = true;
app.activities.remove(r);
throw e;
}
} finally {
endDeferResume();
}

......

return true;
}

方法中需要關注的部分已經用註釋說明了，在realStartActivityLocked中最主要的工作就是建立了Activity的啟動事務ClientTransaction，並呼叫ClientLifecycleManager的scheduleTransaction方法啟動它。接下來，看ClientTransaction事務中是怎麼啟動Activity的。

ClientLifecycleManager->scheduleTransaction

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

呼叫ClientTransaction的schedule方法

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

這裡呼叫了mClient的scheduleTransaction方法，那麼這裡的mClient是從哪來的呢。很容易想到，是在建立ClientTransaction事務物件的時候賦值的，也就是呼叫obtain方法時。

ClientTransaction->obtain

public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;

return instance;
}

我們回到ActivityStackSupervisor的realStartActivityLocked方法

ActivityStackSupervisor->realStartActivityLocked

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {

......

try {

......

// Create activity launch transaction.
// 建立Activity啟動事務
// ClientTransaction.obtain方法如下：
// public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
//ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
//if (instance == null) {
//instance = new ClientTransaction();
//}
//instance.mClient = client;
//instance.mActivityToken = activityToken;
//
//return instance;
// }
// 這裡傳入的app.thread會賦值給ClientTransaction的成員變數mClient，
// 而ClientTransaction會呼叫mClient.scheduleTransaction(this)來執行事務
// 所以事務最終是呼叫app.thread的scheduleTransaction執行。
// 而這個app.thread是ActivityThread的內部類ApplicationThread。
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));

// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);

// Schedule transaction.
// 執行Activity啟動事務
mService.getLifecycleManager().scheduleTransaction(clientTransaction);

......

} catch (RemoteException e) {
if (r.launchFailed) {
// 第二次啟動失敗的異常處理
return false;
}

// 第一次啟動失敗，重試
r.launchFailed = true;
app.activities.remove(r);
throw e;
}
} finally {
endDeferResume();
}

......

return true;
}

可以看到，賦值給mClient的是app.thread，所以事務最終是呼叫的app.thread的scheduleTransaction方法來執行，而這個app.thread是ActivityThread的內部類ApplicationThread。所以流程轉到了ActivityThread的內部類ApplicationThread中。

ActivityThread->ApplicationThread->scheduleTransaction

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

這裡還是呼叫了ActivityThread的scheduleTransaction方法。但是在檢視ActivityThread類就會發現ActivityThread類中並沒有scheduleTransaction這個方法。因此自然會想到很可能是繼承的父類中的方法。ActivityThread繼承的是ClientTransactionHandler類。到ClientTransactionHandler類中一查，果然發現了scheduleTransaction方法。所以這裡最終呼叫的就是ClientTransactionHandler中的scheduleTransaction方法。

ClientTransactionHandler->scheduleTransaction

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

這裡呼叫了sendMessage方法，而sendMessage是一個抽象方法，所以這裡呼叫的是ActivityThread類中的sendMessage實現。

ActivityThread->sendMessage

private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) Slog.v(
TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
+ ": " + arg1 + " / " + obj);
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}

這裡就是生成了一個Message物件，並向mH這個Handler傳送該訊息。所以這裡mH將會接受到一個what為ActivityThread.H.EXECUTE_TRANSACTION的訊息。去檢視Handler中對EXECUTE_TRANSACTION訊息的處理。

ActivityThread->H->handleMessage

case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// 呼叫TransactionExecutor的execute方法
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;

這裡呼叫了TransactionExecutor的execute方法

TransactionExecutor->execute

public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

executeCallbacks(transaction);

executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}

這裡呼叫了executeCallbacks和executeLifecycleState兩個方法，檢視兩個方法就會發現，這兩個方法最後都會呼叫cycleToPath這個方法。

TransactionExecutor->cycleToPath

private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState) {
final int start = r.getLifecycleState();
log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path);
}

TransactionExecutor->performLifecycleSequence

private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
log("Transitioning to state: " + state);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token, false /* show */,
0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}

看到這裡就豁然開朗了，Activity的生命週期就是在這裡進行一個相關方法的呼叫。

這裡的成員變數mTransactionHandler是一個ClientTransactionHandler物件，在ClientTransactionHandler中這些方法都是抽象方法，這裡執行的是ClientTransactionHandler的實現類ActivityThread中的handleLaunchActivity方法。

ActivityThread->handleLaunchActivity

public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;

if (r.profilerInfo != null) {
mProfiler.setProfiler(r.profilerInfo);
mProfiler.startProfiling();
}

// Make sure we are running with the most recent config.
handleConfigurationChanged(null, null);

if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);

// Initialize before creating the activity
if (!ThreadedRenderer.sRendererDisabled) {
GraphicsEnvironment.earlyInitEGL();
}
//建立WindowManagerServer
WindowManagerGlobal.initialize();

// 通過反射建立指定的Activity，並回調Activity的performCreate方法執行onCreate
final Activity a = performLaunchActivity(r, customIntent);

if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
// If there was an error, for any reason, tell the activity manager to stop us.
try {
ActivityManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}

return a;
}

到這，Activity的啟動流程也就走完了。

可以看到，一個startActivity方法在原始碼中的處理是多麼的複雜。如果我們不去閱讀原始碼的話，根本不會對Activity的啟動有一個更深層的理解。所以作為開發，保持一個閱讀原始碼的習慣是非常重要的。

希望本文能對各位讀者有一點幫助，也歡迎指出文章中的錯誤，謝謝大家。