Android啟動(dòng)流程源碼解析（二）
在之前的Android啟動(dòng)流程源碼解析(一)源碼分析中，我們最后遺留下來(lái)一個(gè)問(wèn)題。那就是我們的Activity的啟動(dòng)是啥時(shí)候處理的啊？上萬(wàn)行的分析，也沒(méi)看到我們想要的onCreate啥的。其實(shí)就是resumeFocusedStacksTopActivities方法，所以我們這篇文章就從這個(gè)方法開(kāi)始。
resumeFocusedStacksTopActivities
boolean resumeFocusedStacksTopActivities() {
return resumeFocusedStacksTopActivities(null, null, null);
}
boolean resumeFocusedStacksTopActivities(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
boolean result = false;
if (targetStack != null && (targetStack.isTopStackOnDisplay()|| getTopDisplayFocusedStack() == targetStack)) {
//******重點(diǎn)方法******如果當(dāng)前的activitystack正好處于屏幕的頂部，那么直接調(diào)用將target設(shè)置到頂部顯示
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
//標(biāo)記是否已經(jīng)顯示在屏幕上
boolean resumedOnDisplay = false;
final ActivityDisplay display = mActivityDisplays.get(displayNdx);
for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = display.getChildAt(stackNdx);
//獲取到當(dāng)前ActivityStack頂部正在運(yùn)行的Activity
final ActivityRecord topRunningActivity = stack.topRunningActivityLocked();
if (!stack.isFocusableAndVisible() || topRunningActivity == null) {
continue;
}
if (stack == targetStack) {
//上面已經(jīng)做過(guò)resume處理了，所以這里我們就不再做處理了
resumedOnDisplay |= result;
continue;
}
if (display.isTopStack(stack) && topRunningActivity.isState(RESUMED)) {
stack.executeAppTransition(targetOptions);
} else {
resumedOnDisplay |= topRunningActivity.makeActiveIfNeeded(target);
}
}
//如果仍然沒(méi)有顯示在屏幕上，那么就獲取到屏幕當(dāng)前持有焦點(diǎn)的ActivityStack，然后將activity顯示在上面
if (!resumedOnDisplay) {
final ActivityStack focusedStack = display.getFocusedStack();
if (focusedStack != null) {
focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
}
}
return result;
}
這里我們只需要關(guān)注一個(gè)方法 resumeTopActivityUncheckedLocked ，這個(gè)方法也特別長(zhǎng)，我們就拆分開(kāi)，只關(guān)注重點(diǎn)方法即可
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
// Protect against recursion.
mInResumeTopActivity = true;
//***重點(diǎn)關(guān)注******
result = resumeTopActivityInnerLocked(prev, options);
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mInResumeTopActivity = false;
}
return result;
}
這里我們也只關(guān)注resumeTopActivityInnerLocked方法
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
if (mResumedActivity != null) {
//****重點(diǎn)方法 ****** 調(diào)用acitivity的pause方法
pausing |= startPausingLocked(userLeaving, false, next, false);
}
...
//進(jìn)行activity的創(chuàng)建處理
mStackSupervisor.startSpecificActivityLocked(next, true, false);
...
}
代碼也很長(zhǎng)，我們只提取了兩個(gè)比較重要的函數(shù)，一個(gè)是調(diào)用onPause生命周期函數(shù)，另一個(gè)是調(diào)用onCreate生命周期函數(shù)的。
onPause的暫停過(guò)程
我們首先來(lái)看一下是如何一步步通過(guò)調(diào)度來(lái)執(zhí)行onPause的生命周期調(diào)度的
//ActivityStack.java
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming, boolean pauseImmediately) {
...
//當(dāng)前正在顯示的Activity
ActivityRecord prev = mResumedActivity;
//當(dāng)前正在顯示的Activity需要執(zhí)行暫停操作了。
//將其賦值給mPausingActivity成員變量。
mPausingActivity = prev;
mLastPausedActivity = prev;
//Activity綁定了對(duì)應(yīng)的APP？難道有不綁定的情況么？
if (prev.attachedToProcess()) {
...
//******重點(diǎn)方法****
mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,prev.configChangeFlags, pauseImmediately));
...
重點(diǎn)方法已經(jīng)標(biāo)注出來(lái)了。我們先看看它的參數(shù)的創(chuàng)建過(guò)程。
PauseActivityItem.obtain
//PauseActivityItem.java
//從池中取出一個(gè)PauseActivityItem類
public static PauseActivityItem obtain(boolean finished, boolean userLeaving, int configChanges, boolean dontReport) {
PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);
if (instance == null) {
instance = new PauseActivityItem();
}
instance.mFinished = finished;
instance.mUserLeaving = userLeaving;
instance.mConfigChanges = configChanges;
instance.mDontReport = dontReport;
return instance;
}
//ObjectPool.java
public static <T extends ObjectPoolItem> T obtain(Class<T> itemClass) {
synchronized (sPoolSync) {
@SuppressWarnings("unchecked")
final ArrayList<T> itemPool = (ArrayList<T>) sPoolMap.get(itemClass);
if (itemPool != null && !itemPool.isEmpty()) {
return itemPool.remove(itemPool.size() - 1);
}
return null;
}
}
可以看到，對(duì)于PauseActivityItem的獲取，是通過(guò)享元模式 來(lái)進(jìn)行處理的。
回到主干。
這的mService是ActivityTaskManagerService，getLifecycleManager方法返回的是ClientLifecycleManager對(duì)象。
private final ClientLifecycleManager mLifecycleManager;
mLifecycleManager = new ClientLifecycleManager();
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
scheduleTransaction
//ClientLifecycleManager.java
//調(diào)用一次生命周期的調(diào)度請(qǐng)求
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,@NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
scheduleTransaction(clientTransaction);
}
//實(shí)際的調(diào)度方法
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
//回收
transaction.recycle();
}
}
//創(chuàng)建一個(gè)持有狀態(tài)的事務(wù)類
private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
@NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
clientTransaction.setLifecycleStateRequest(stateRequest);
return clientTransaction;
}
這里最終會(huì)調(diào)用ClientTransaction對(duì)象的schedule方法。
//ClientTransaction.java
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
這里的mClient是一個(gè)IApplicationThread，其Server端是ActivityThread#ApplicationThread。所以最終調(diào)用的是ApplicationThread的scheduleTransaction方法
//ActivityThread.java
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//會(huì)調(diào)用ActivityThread.scheduleTransaction方法->該方法位于ActivityThread的父類中
ActivityThread.this.scheduleTransaction(transaction);
}
//ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
//執(zhí)行預(yù)處理
transaction.preExecute(this);
//通過(guò)Handler機(jī)制發(fā)送事務(wù)請(qǐng)求
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
Handler消息機(jī)制就不貼出來(lái)了，直接看其是怎么處理的。
//ActivityThread.java
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
case EXECUTE_TRANSACTION://執(zhí)行生命周期的調(diào)度工作
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
當(dāng)接收到Handler以后，會(huì)調(diào)用TransactionExecutor的execute()方法。
//TransactionExecutor.java
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
...
//循環(huán)遍歷回調(diào)請(qǐng)求的所有狀態(tài)，并在適當(dāng)?shù)臅r(shí)間執(zhí)行它們
executeCallbacks(transaction);
//執(zhí)行生命周期的改變
executeLifecycleState(transaction);
}
ClientTransaction存在兩種事務(wù),
- 一種是通過(guò)setLifecycleStateRequest設(shè)置一個(gè)對(duì)象的事務(wù)類型，用于表示事務(wù)執(zhí)行以后，客戶端應(yīng)該處于的生命周期狀態(tài)
- 一種是addCallback，增加對(duì)客戶端的事務(wù)類型回調(diào)，對(duì)客戶端一系列的回調(diào)。
這兩個(gè)不同的類型，在這里就會(huì)存在不同的處理方法。對(duì)于第一種會(huì)在executeCallbacks中進(jìn)行處理，第二種則會(huì)在executeLifecycleState中進(jìn)行處理。
我們這兒的暫停，是通過(guò)第二種來(lái)進(jìn)行設(shè)置的，所以我們直接看executeLifecycleState這個(gè)方法。
//TransactionExecutor.java
//如果事務(wù)請(qǐng)求，則轉(zhuǎn)換到最終狀態(tài)
private void executeLifecycleState(ClientTransaction transaction) {
// ActivityStackSupervisor.java中進(jìn)行了這個(gè)設(shè)置
// final ActivityLifecycleItem lifecycleItem;
// if (andResume) {
// lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
// } else {
// lifecycleItem = PauseActivityItem.obtain();
// }
// clientTransaction.setLifecycleStateRequest(lifecycleItem);
//所以這里的lifecycleItem可能是ResumeActivityItem或者PauseActivityItem或者其他的生命周期相關(guān)類
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
//如果不是通過(guò)setLifecycleStateRequest設(shè)置的，那么該方法不需要處理，直接返回即可
return;
}
//使用適當(dāng)?shù)膮?shù)執(zhí)行最后的轉(zhuǎn)換
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
我們這里的lifecycleItem是我們剛才創(chuàng)建的PauseActivityItem，這里會(huì)執(zhí)行其execute方法。
//PauseActivityItem.java
@Override
public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
//這里的client，是Activity獨(dú)享
client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,"PAUSE_ACTIVITY_ITEM");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
這里的client對(duì)象我們需要回退去跟蹤一下
//ActivityThread.java
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
//TransactionExecutor.java
//在ActivityThread類中中調(diào)用了mTransactionExecutor = new TransactionExecutor(this)這個(gè)方法，其中的mTransactionHandler是ActivityThread本身
public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
mTransactionHandler = clientTransactionHandler;
}
所以說(shuō)，最終調(diào)用的是ActivityThread的handlePauseActivity方法
//ActivityThread.java
public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,int configChanges, PendingTransactionActions pendingActions, String reason) {
//獲取對(duì)應(yīng)的ActivityClientRecord對(duì)象
ActivityClientRecord r = mActivities.get(token);
if (r != null) {
...
//***重點(diǎn)方法***，執(zhí)行pause方法
performPauseActivity(r, finished, reason, pendingActions);
...
}
}
private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
PendingTransactionActions pendingActions) {
...
//****重點(diǎn)方法****
performPauseActivityIfNeeded(r, reason);
...
return shouldSaveState ? r.state : null;
}
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
...
r.activity.mCalled = false;
//重點(diǎn)方法，通過(guò)Instrumentation調(diào)用onPause生命周期
mInstrumentation.callActivityOnPause(r.activity);
...
}
最終會(huì)通過(guò)Instrumentation調(diào)用callActivityOnPause方法。
//Instrumentation.java
public void callActivityOnPause(Activity activity) {
activity.performPause();
}
//Activity.java
final void performPause() {
dispatchActivityPrePaused();
mDoReportFullyDrawn = false;
//管理的Fragment的處理
mFragments.dispatchPause();
mCalled = false;
//調(diào)用了onPause生命周期方法
onPause();
writeEventLog(LOG_AM_ON_PAUSE_CALLED, "performPause");
//設(shè)置mResumed為false，表示當(dāng)前activity沒(méi)有展示
mResumed = false;
//調(diào)用一些回調(diào)函數(shù)
dispatchActivityPostPaused();
}
到這里為止，原來(lái)在我們面前展示的那個(gè)Activity調(diào)用了其onPause方法。
Activity的創(chuàng)建過(guò)程
回到主線的resumeTopActivityInnerLocked方法中，當(dāng)執(zhí)行完startPausingLocked方法后，會(huì)調(diào)用mStackSupervisor.startSpecificActivityLocked方法
//ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
//根據(jù)uid和pid，獲取activity對(duì)應(yīng)的進(jìn)行和線程信息
final WindowProcessController wpc =mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) {
//如果進(jìn)程和線程都存在，執(zhí)行后面的代碼
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
knownToBeDead = true;
}
//通過(guò)message進(jìn)行進(jìn)程的啟動(dòng)。
final Message msg = PooledLambda.obtainMessage(
ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
mService.mH.sendMessage(msg);
} finally {
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
}
如果要啟動(dòng)的activity所在的進(jìn)程和線程都存在，那么直接調(diào)用realStartActivityLocked方法進(jìn)行啟動(dòng)，否則的話，就會(huì)調(diào)用Handler機(jī)制進(jìn)行進(jìn)程的創(chuàng)建。
realStartActivityLocked
//真正執(zhí)行Activity啟動(dòng)的方法
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException {
//如果還有activity沒(méi)有暫停，這里會(huì)直接返回false
if (!mRootActivityContainer.allPausedActivitiesComplete()) {
return false;
}
final TaskRecord task = r.getTaskRecord();
final ActivityStack stack = task.getStack();
//設(shè)置標(biāo)志位，不再接收其他activity的resume的操作
beginDeferResume();
try {
...
//創(chuàng)建了一個(gè)Activity事務(wù)
final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
//增加一個(gè)要執(zhí)行的事務(wù)LaunchActivityItem。
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.icicle, r.persistentState, results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken));
final ActivityLifecycleItem lifecycleItem;
//設(shè)置其生命周期LifecycleStateRequest
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//執(zhí)行事務(wù)的調(diào)度
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
proc.onStartActivity(mService.mTopProcessState, r.info);
return true;
}
在這個(gè)方法里面，創(chuàng)建了一個(gè)事務(wù)，在事務(wù)中增加了一個(gè)callback回調(diào)，然后通過(guò)setLifecycleStateRequest設(shè)置了一個(gè)生命周期，最后通過(guò)scheduleTransaction執(zhí)行了調(diào)度。在前面的onPause中，我們梳理了整個(gè)調(diào)度的流程，最后會(huì)調(diào)用到LaunchActivityItem的execute，然后會(huì)調(diào)用生命周期所對(duì)應(yīng)的ResumeActivityItem的execute。
我們挨個(gè)看，先看LaunchActivityItem的調(diào)用
//LaunchActivityItem.java
//一般會(huì)在TransactionExecutor中調(diào)用這個(gè)方法
//ClientTransactionHandler實(shí)際是ActivityThread對(duì)象，所以這里會(huì)執(zhí)行activitythread類中的handleLaunchActivity方法
@Override
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);
//調(diào)用activitythread類中的handleLaunchActivity方法
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
其本質(zhì)調(diào)用的是ActivityThread中的handleLaunchActivity方法。
這部分的功能，我們?cè)?a target="_blank">Android布局窗口繪制分析中進(jìn)行過(guò)解析。這里不再往下進(jìn)行解析了。
我們直接跳過(guò)這部分，來(lái)看看如果啟動(dòng)的activity所在的進(jìn)程和線程都存在。會(huì)進(jìn)行進(jìn)程的創(chuàng)建工作。這部分我們后面專門再進(jìn)行一篇關(guān)于進(jìn)程創(chuàng)建的解析工作。
本文由 開(kāi)了肯 發(fā)布！
同步公眾號(hào)[開(kāi)了肯]
