前言
最近在閱讀Android源碼時，發(fā)現(xiàn)最新的Android9.0源碼中startActivity啟動Activity的流程相比于低版本的Android源碼來說改動較大递递。故寫下此文恩溅，記錄下源碼追蹤流程，方便以后自己復(fù)查，同時也分享給有需要的讀者。
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);
}
}
直接調(diào)用startActivityForResult
Activity->startActivityForResult
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
// mParent指的是Activity 賦值是在內(nèi)部API調(diào)用setParent方法
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
//Instrumentation為工具類ActivityResult為其靜態(tài)內(nèi)部類 工具類調(diào)用執(zhí)行開始Activity方法execStartActity
//mMainThread為ActivityThread 蜜氨，getApplicationThread()方法獲取的是ApplicationThread實例
//ApplicationThread是ActivityThread的內(nèi)部類 該類繼承ApplicationThreadNative抽象類，
//而ApplicationThreadNative繼承Binder類并實現(xiàn)IApplicationThread接口
//IApplictionThread繼承了IInterface接口
//Binder類繼承IBinder接口捎泻，這就是為什么execStartActivity方法的第二個參數(shù)定義為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);
}
}
}
調(diào)用了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的監(jiān)測器是Instrumentation的靜態(tài)內(nèi)部類记劝，
//當(dāng)一個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返回的狀態(tài)碼
// 這里通過IPC機制，調(diào)用了ActivityManagerService中的startActivity方法
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
//檢查Activity是否啟動成功若未啟動成功則拋出對應(yīng)異常
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
可以看到族扰，這個方法最后是調(diào)用了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的跨進程通信獲取到了系統(tǒng)服務(wù)ActivityManagerService定欧，所以ActivityManager.getService().startActivity()是調(diào)用了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，進行后續(xù)頁面跳轉(zhuǎn)
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對象砍鸠，然后設(shè)置了一些屬性扩氢，最后調(diào)用了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方法中調(diào)用了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方法中調(diào)用了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參數(shù)進行解析獲取Activity的相關(guān)信息双饥，并把數(shù)據(jù)保存在aInfo變量中
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
synchronized (mService) {
...略
final ActivityRecord[] outRecord = new ActivityRecord[1];
// 調(diào)用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;
}
}
調(diào)用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的權(quán)限
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);
...
// 如果我們開始的活動與當(dāng)前恢復(fù)的活動的UID不同，檢查是否允許應(yīng)用程序切換弟断。
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);
// 繼續(xù)調(diào)用方法
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity);
}
繼續(xù)調(diào)用同名方法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();
// 調(diào)用startActivityUnchecked方法咏花，返回結(jié)果
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity);
} finally {
// 如果我們無法繼續(xù)，請解除活動與任務(wù)的關(guān)聯(lián)阀趴。使活動處于不完整狀態(tài)可能會導(dǎo)致問題昏翰，例如在沒有窗口容器的情況下執(zhí)行操作。
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;
}
調(diào)用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);
// 判斷是否應(yīng)將新Activity插入到現(xiàn)有任務(wù)棧中
// 如果不需要刘急，則返回null棚菊，如果需要，則返回該任務(wù)棧信息
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");
}
// 關(guān)注這里
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;
}
這里需要關(guān)注的是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;
}
可以看到叔汁，這里調(diào)用了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;
}
這里調(diào)用了resumeTopActivityInnerLocked方法统求，resumeTopActivityInnerLocked方法中會調(diào)用startSpecificActivityLocked方法检碗，然后再調(diào)用realStartActivityLocked方法。Activity的啟動事務(wù)就是在realStartActivityLocked方法中啟動的球订。
ActivityStackSupervisor->realStartActivityLocked
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
......
try {
......
// Create activity launch transaction.
// 創(chuàng)建Activity啟動事務(wù)
// 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會調(diào)用mClient.scheduleTransaction(this)來執(zhí)行事務(wù)
// 所以事務(wù)最終是調(diào)用app.thread的scheduleTransaction執(zhí)行。
// 而這個app.thread是ActivityThread的內(nèi)部類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.
// 執(zhí)行Activity啟動事務(wù)
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;
}
方法中需要關(guān)注的部分已經(jīng)用注釋說明了，在realStartActivityLocked中最主要的工作就是創(chuàng)建了Activity的啟動事務(wù)ClientTransaction开睡，并調(diào)用ClientLifecycleManager的scheduleTransaction方法啟動它因苹。接下來，看ClientTransaction事務(wù)中是怎么啟動Activity的篇恒。
ClientLifecycleManager->scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
// 執(zhí)行事務(wù)
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();
}
}
調(diào)用ClientTransaction的schedule方法
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
這里調(diào)用了mClient的scheduleTransaction方法扶檐，那么這里的mClient是從哪來的呢。很容易想到胁艰，是在創(chuàng)建ClientTransaction事務(wù)對象的時候賦值的款筑，也就是調(diào)用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.
// 創(chuàng)建Activity啟動事務(wù)
// 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會調(diào)用mClient.scheduleTransaction(this)來執(zhí)行事務(wù)
// 所以事務(wù)最終是調(diào)用app.thread的scheduleTransaction執(zhí)行奈梳。
// 而這個app.thread是ActivityThread的內(nèi)部類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.
// 執(zhí)行Activity啟動事務(wù)
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，所以事務(wù)最終是調(diào)用的app.thread的scheduleTransaction方法來執(zhí)行殴泰，而這個app.thread是ActivityThread的內(nèi)部類ApplicationThread于宙。所以流程轉(zhuǎn)到了ActivityThread的內(nèi)部類ApplicationThread中。
ActivityThread->ApplicationThread->scheduleTransaction
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
這里還是調(diào)用了ActivityThread的scheduleTransaction方法悍汛。但是在查看ActivityThread類就會發(fā)現(xiàn)ActivityThread類中并沒有scheduleTransaction這個方法捞魁。因此自然會想到很可能是繼承的父類中的方法。ActivityThread繼承的是ClientTransactionHandler類离咐。到ClientTransactionHandler類中一查署驻，果然發(fā)現(xiàn)了scheduleTransaction方法。所以這里最終調(diào)用的就是ClientTransactionHandler中的scheduleTransaction方法健霹。
ClientTransactionHandler->scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
這里調(diào)用了sendMessage方法旺上，而sendMessage是一個抽象方法，所以這里調(diào)用的是ActivityThread類中的sendMessage實現(xiàn)糖埋。
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發(fā)送該消息。所以這里mH將會接受到一個what為ActivityThread.H.EXECUTE_TRANSACTION的消息瞳别。去查看Handler中對EXECUTE_TRANSACTION消息的處理征候。
ActivityThread->H->handleMessage
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// 調(diào)用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;
這里調(diào)用了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");
}
這里調(diào)用了executeCallbacks和executeLifecycleState兩個方法杭攻，查看兩個方法就會發(fā)現(xiàn)，這兩個方法最后都會調(diào)用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的生命周期就是在這里進行一個相關(guān)方法的調(diào)用。
這里的成員變量mTransactionHandler是一個ClientTransactionHandler對象跑揉，在ClientTransactionHandler中這些方法都是抽象方法锅睛，這里執(zhí)行的是ClientTransactionHandler的實現(xiàn)類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();
}
//創(chuàng)建WindowManagerServer
WindowManagerGlobal.initialize();
// 通過反射創(chuàng)建指定的Activity历谍，并回調(diào)Activity的performCreate方法執(zhí)行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方法在源碼中的處理是多么的復(fù)雜印蔬。如果我們不去閱讀源碼的話，根本不會對Activity的啟動有一個更深層的理解脱衙。所以作為開發(fā)侥猬，保持一個閱讀源碼的習(xí)慣是非常重要的。
希望本文能對各位讀者有一點幫助捐韩，也歡迎指出文章中的錯誤退唠，謝謝大家。
