上一篇我們分析了Activity的啟動(dòng)流程，由于代碼量很大，還是沒有分析的很詳細(xì)，但是基本流程都出來了，更詳細(xì)的東西還是要去看源碼，源碼在我文章的最后有給出，里面有我添加的詳細(xì)的注釋。這一章來分析Activity的finish過程，這個(gè)問題在兩年前我去面試金山的時(shí)候曾經(jīng)被問到過，那時(shí)候?qū)υ创a基本沒什么了解，所以當(dāng)時(shí)根本是不了解的，今天我們就來分析一下finish的過程到底做了哪些處理，最后對Activity的整個(gè)啟動(dòng)過程以及finish過程繪制流程圖，以方便我們記憶。
finish代碼分析
首先先貼一張時(shí)序圖：
ActivityFinish.jpg
Activity的finish方法就是調(diào)用的父類的finish方法：
Step1.Activity.finish
public void finish() {
finish(DONT_FINISH_TASK_WITH_ACTIVITY);
}
這里調(diào)用finish方法，傳入?yún)?shù)DONT_FINISH_TASK_WITH_ACTIVITY，這個(gè)參數(shù)是在finish掉Activity的時(shí)候不finish掉Task。
Step2.Activity.finish
private void finish(int finishTask) {
...
if (ActivityManagerNative.getDefault()
.finishActivity(mToken, resultCode, resultData, finishTask)) {
mFinished = true;
}
...
}
ActivityManagerNative.getDefault()方法其實(shí)我們在前面文章提到過，得到的是AMP（ActivityManagerProxy）。
Step3.AMP.finishActivity
public boolean finishActivity(IBinder token, int resultCode, Intent resultData, int finishTask)
throws RemoteException {
...
mRemote.transact(FINISH_ACTIVITY_TRANSACTION, data, reply, 0);
...
}
通過Binder調(diào)用AMS的finishActivity方法。
Step4.AMS.finishActivity
public final boolean finishActivity(IBinder token, int resultCode, Intent resultData,
int finishTask) {
...
synchronized (this) {
// 根據(jù)token（IBinder）獲取Activity的對象封裝ActivityRecord
ActivityRecord r = ActivityRecord.isInStackLocked(token);
if (r == null) {
return true;
}
// Keep track of the root activity of the task before we finish it
TaskRecord tr = r.task;
// 從棧底部獲取第一沒有被finish的Activity對象封裝
ActivityRecord rootR = tr.getRootActivity();
...
if (mController != null) {
// Find the first activity that is not finishing.
// 獲取第一個(gè)沒有被回收的Activity
ActivityRecord next = r.task.stack.topRunningActivityLocked(token, 0);
if (next != null) {
...
}
}
final long origId = Binder.clearCallingIdentity();
try {
// 傳入的finishTask是DONT_FINISH_TASK_WITH_ACTIVITY，所以下面參數(shù)是false
final boolean finishWithRootActivity =
finishTask == Activity.FINISH_TASK_WITH_ROOT_ACTIVITY;
// 這里if中條件為false所以走else語句
if (finishTask == Activity.FINISH_TASK_WITH_ACTIVITY
|| (finishWithRootActivity && r == rootR)) {
res = removeTaskByIdLocked(tr.taskId, false, finishWithRootActivity);
...
} else {
res = tr.stack.requestFinishActivityLocked(token, resultCode,
resultData, "app-request", true);
...
}
return res;
} finally {
...
}
}
}
上面try語句中會(huì)走else語句中的方法也就是ActivityStack.requestFinishActivityLocked
Step5.ActivityStack.requestFinishActivityLocked
final boolean requestFinishActivityLocked(IBinder token, int resultCode,
Intent resultData, String reason, boolean oomAdj) {
ActivityRecord r = isInStackLocked(token);
...
finishActivityLocked(r, resultCode, resultData, reason, oomAdj);
return true;
}
調(diào)用finishActivityLocked方法
Step6.ActivityStack.finishActivityLocked
final boolean finishActivityLocked(ActivityRecord r, int resultCode, Intent resultData,
String reason, boolean oomAdj) {
if (r.finishing) {// 如果要清理的的正在finish，則不需要再清理
Slog.w(TAG, "Duplicate finish request for " + r);
return false;
}
// 標(biāo)記開始finish
r.makeFinishingLocked();
...
// 停止鍵盤分發(fā)事件
r.pauseKeyDispatchingLocked();
adjustFocusedActivityLocked(r, "finishActivity");
finishActivityResultsLocked(r, resultCode, resultData);
// 如果任務(wù)中沒有了Activity要結(jié)束任務(wù)
final boolean endTask = index <= 0;
final int transit = endTask ? TRANSIT_TASK_CLOSE : TRANSIT_ACTIVITY_CLOSE;
if (mResumedActivity == r) {// 如果當(dāng)前顯示的Activity就是要結(jié)束的Activity
...
if (mPausingActivity == null) {
// 開始暫停Activity
startPausingLocked(false, false, null, false);
}
if (endTask) {// 如果任務(wù)中沒有了Activity，則移除任務(wù)
mStackSupervisor.removeLockedTaskLocked(task);
}
} else if (r.state != ActivityState.PAUSING) {// 如果要移除的Activity不是Pausing狀態(tài)并且不是正在顯示的Activity
...
return finishCurrentActivityLocked(r, (r.visible || r.nowVisible) ?
FINISH_AFTER_VISIBLE : FINISH_AFTER_PAUSE, oomAdj) == null;
} else {
...
}
return false;
}
這里首先調(diào)用ActivityRecord.makeFinishingLocked標(biāo)記開始結(jié)束Activity，然后調(diào)用ActivityRecord.pauseKeyDispatchingLocked方法停止鍵盤事件分發(fā)。然后調(diào)用adjustFocusedActivityLocked方法，調(diào)整Activity的焦點(diǎn)狀體。
Step7.ActivityStack.adjustFocusedActivityLocked
private void adjustFocusedActivityLocked(ActivityRecord r, String reason) {
// 如果當(dāng)前棧沒有焦點(diǎn)，或者當(dāng)前Activity也不是當(dāng)前有焦點(diǎn)的Activity，返回
if (!mStackSupervisor.isFocusedStack(this) || mService.mFocusedActivity != r) {
return;
}
// 獲取棧頂正在運(yùn)行的Activity
final ActivityRecord next = topRunningActivityLocked();
final String myReason = reason + " adjustFocus";
if (next != r) {// 如果棧頂正在運(yùn)行的不是當(dāng)前要結(jié)束的Activity
if (next != null && StackId.keepFocusInStackIfPossible(mStackId) && isFocusable()) {
mService.setFocusedActivityLocked(next, myReason);
return;
} else {
final TaskRecord task = r.task;
if (r.frontOfTask && task == topTask() && task.isOverHomeStack()) {
final int taskToReturnTo = task.getTaskToReturnTo();
if (!mFullscreen
&& adjustFocusToNextFocusableStackLocked(taskToReturnTo, myReason)) {
return;
}
if (mStackSupervisor.moveHomeStackTaskToTop(taskToReturnTo, myReason)) {
return;
}
}
}
}
mService.setFocusedActivityLocked(mStackSupervisor.topRunningActivityLocked(), myReason);
}
當(dāng)前Activity要finish掉，就找找到下一個(gè)應(yīng)該獲取焦點(diǎn)的Activity，在該Activity被finish掉之后顯示出來。
Step8.ActivityStack.finishActivityResultsLocked
final void finishActivityResultsLocked(ActivityRecord r, int resultCode, Intent resultData) {
// send the result
ActivityRecord resultTo = r.resultTo;
if (resultTo != null) {
...
resultTo.addResultLocked(r, r.resultWho, r.requestCode, resultCode,
resultData);
r.resultTo = null;
} else if (DEBUG_RESULTS) Slog.v(TAG_RESULTS, "No result destination from " + r);
...
}
如果要接收Result的Activity描述對象ActivityRecord還存在，就將result相關(guān)信息封裝成ActivityResult對象放到ActivityResult列表中保存起來。然后置空該Activity對應(yīng)的ActivityRecord對象中的信息。
Step9.ActivityStack.startPausingLocked
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean dontWait) {
if (mPausingActivity != null) {
Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity
+ " state=" + mPausingActivity.state);
if (!mService.isSleepingLocked()) {// 如果沒有在睡眠，則完成Pause狀態(tài)
completePauseLocked(false, resuming);
}
}
// prev指向源Activity
ActivityRecord prev = mResumedActivity;
if (prev == null) {
if (resuming == null) {
Slog.wtf(TAG, "Trying to pause when nothing is resumed");
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
return false;
}
if (mActivityContainer.mParentActivity == null) {
// Top level stack, not a child. Look for child stacks.
// 暫停所有子棧的Activity
mStackSupervisor.pauseChildStacks(prev, userLeaving, uiSleeping, resuming, dontWait);
}
...
// 改變狀態(tài)
prev.state = ActivityState.PAUSING;
...
// 獲取正在啟動(dòng)的Activity組件
final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
...
if (prev.app != null && prev.app.thread != null) {
...
// 通知源Activity組件，暫停源Activity以便有機(jī)會(huì)執(zhí)行一些數(shù)據(jù)保存操作，
// 這里如果目標(biāo)sdk<11會(huì)調(diào)用onSaveInstanceState，然后調(diào)用onPause
prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
userLeaving, prev.configChangeFlags, dontWait);
...
} else {
...
}
...
}
這里主要是在finish之前pause該Activity，如果狀態(tài)正常會(huì)調(diào)用schedulePauseActivity方法，最終調(diào)用Activity的onPause方法，這個(gè)過程我們在前面講過幾次了，這里就不再分析，比較簡單。我們接著看核心的代碼。
Step10.ActivityStack.finishCurrentActivityLocked
final ActivityRecord finishCurrentActivityLocked(ActivityRecord r, int mode, boolean oomAdj) {
// 如果當(dāng)前要finish的Activity正在顯示，而復(fù)用的Activity還沒有顯示，那么延遲finish，
// 直到復(fù)用Activity顯示
// 獲取頂部正在運(yùn)行的Activity
final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
// 如果是顯示后在finish，并且要結(jié)束的正在顯示或者將要顯示，并且頂部運(yùn)行的存在而且沒有顯示
if (mode == FINISH_AFTER_VISIBLE && (r.visible || r.nowVisible)
&& next != null && !next.nowVisible) {
// 如果當(dāng)前要結(jié)束的Activity不在正在停止列表中則添加到停止列表中
if (!mStackSupervisor.mStoppingActivities.contains(r)) {
addToStopping(r, false /* immediate */);
}
...
return r;
}
// make sure the record is cleaned out of other places.
// 從各個(gè)列表中清理這個(gè)將要被finish的Activity
...
final ActivityState prevState = r.state;// 存儲(chǔ)清理之前的狀態(tài)
r.state = ActivityState.FINISHING;// 設(shè)置為正在finish狀態(tài)
// 判斷當(dāng)前正在清理的Activity是否在當(dāng)前獲取焦點(diǎn)的棧中
final boolean finishingActivityInNonFocusedStack
= r.task.stack != mStackSupervisor.getFocusedStack()
&& prevState == ActivityState.PAUSED && mode == FINISH_AFTER_VISIBLE;
if (mode == FINISH_IMMEDIATELY
|| (prevState == ActivityState.PAUSED
&& (mode == FINISH_AFTER_PAUSE || mStackId == PINNED_STACK_ID))
|| finishingActivityInNonFocusedStack
|| prevState == ActivityState.STOPPED
|| prevState == ActivityState.INITIALIZING) {
...
// 銷毀Activity
boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm");
...
return activityRemoved ? null : r;
}
...
return r;
}
這里是開始銷毀Activity，首先要保存狀態(tài)，然后標(biāo)記開始finish，然后調(diào)用destroyActivityLocked方法開始銷毀。
Step11.ActivityStack.destroyActivityLocked
final boolean destroyActivityLocked(ActivityRecord r, boolean removeFromApp, String reason) {
...
// 清理Activity
cleanUpActivityLocked(r, false, false);
final boolean hadApp = r.app != null;
if (hadApp) {
...
boolean skipDestroy = false;
try {
r.app.thread.scheduleDestroyActivity(r.appToken, r.finishing,
r.configChangeFlags);
} catch (Exception e) {
...
}
...
return removedFromHistory;
}
這里主要有兩部操作，第一步是cleanUpActivityLocked，第二步是scheduleDestroyActivity。我們先看第一步。
Step12.ActivityStack.cleanUpActivityLocked
final void cleanUpActivityLocked(ActivityRecord r, boolean cleanServices,
boolean setState) {
if (mResumedActivity == r) {
mResumedActivity = null;
}
if (mPausingActivity == r) {
mPausingActivity = null;
}
mService.resetFocusedActivityIfNeededLocked(r);
...
// Make sure this record is no longer in the pending finishes list.
// This could happen, for example, if we are trimming activities
// down to the max limit while they are still waiting to finish.
mStackSupervisor.mFinishingActivities.remove(r);
mStackSupervisor.mWaitingVisibleActivities.remove(r);
...
if (cleanServices) {// 是否清理服務(wù)
cleanUpActivityServicesLocked(r);
}
...
}
這里主要是將指向該銷毀的Activity的引用都置空，進(jìn)行釋放，然后將該Activity描述對象從列表中移除該對象，最后是判斷是否清理服務(wù)，其實(shí)主要是綁定該Activity的服務(wù)，如果有綁定則解除綁定。
Step13.ActivityManagerService.resetFocusedActivityIfNeededLocked
// 重新設(shè)置獲取焦點(diǎn)的Activity，如果被清理的不是獲取焦點(diǎn)的，那么不處理，否則將焦點(diǎn)移動(dòng)到另外一個(gè)Activity
final void resetFocusedActivityIfNeededLocked(ActivityRecord goingAway) {
...
// Try to move focus to another activity if possible.
// 如果允許，將焦點(diǎn)移動(dòng)到另外一個(gè)Activity
if (setFocusedActivityLocked(
focusedStack.topRunningActivityLocked(), "resetFocusedActivityIfNeeded")) {
return;
}
...
}
這里調(diào)用setFocusedActivityLocked方法判斷該Activity是不是允許允許將焦點(diǎn)移除。
Step14.ActivityManagerService.setFocusedActivityLocked
boolean setFocusedActivityLocked(ActivityRecord r, String reason) {
if (r == null || mFocusedActivity == r) {// 如果傳入的焦點(diǎn)Activity不存在或者就是顯示在有焦點(diǎn)的Activity則不需要處理了
return false;
}
if (!r.isFocusable()) {// 如果沒有獲取焦點(diǎn)，返回
return false;
}
...
// 獲取之前有焦點(diǎn)的Activity
final ActivityRecord last = mFocusedActivity;
mFocusedActivity = r;// 設(shè)置傳入的Activity為當(dāng)前焦點(diǎn)Activity
if (r.task.isApplicationTask()) {// 當(dāng)前焦點(diǎn)Activity所在任務(wù)是應(yīng)用任務(wù)（不是桌面和最近應(yīng)用界面）
if (mCurAppTimeTracker != r.appTimeTracker) {
...
} else {
startTimeTrackingFocusedActivityLocked();
}
} else {
r.appTimeTracker = null;
}
...
// 將要啟動(dòng)的Activity移動(dòng)到前臺
if (mStackSupervisor.moveActivityStackToFront(r, reason + " setFocusedActivity")) {
mWindowManager.setFocusedApp(r.appToken, true);
}
...
return true;
}
這里看一下注釋，主要是判斷該Activity是否有焦點(diǎn)，是否允許切換焦點(diǎn)。因此要結(jié)束的Activity就要把焦點(diǎn)釋放掉。
Step15.ActivityStack.cleanUpActivityServicesLocked
final void cleanUpActivityServicesLocked(ActivityRecord r) {
// Throw away any services that have been bound by this activity.
if (r.connections != null) {
Iterator<ConnectionRecord> it = r.connections.iterator();
while (it.hasNext()) {
ConnectionRecord c = it.next();
mService.mServices.removeConnectionLocked(c, null, r);
}
r.connections = null;
}
}
上面我們提到這個(gè)方法主要是釋放綁定的服務(wù)，如果沒有則不需要釋放。下面我們回到Step11中提到的第二步。
Step16.ApplicationThreadNative.scheduleDestroyActivity
public final void scheduleDestroyActivity(IBinder token, boolean finishing,
int configChanges) throws RemoteException {
...
mRemote.transact(SCHEDULE_FINISH_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
..
}
這個(gè)很熟悉了。
Step17.ApplicationThread.scheduleDestroyActivity
public final void scheduleDestroyActivity(IBinder token, boolean finishing,
int configChanges) {
sendMessage(H.DESTROY_ACTIVITY, token, finishing ? 1 : 0,
configChanges);
}
通過發(fā)送消息到Handler中來處理。
Step18.ActivityThread.H.handleMessage
public void handleMessage(Message msg) {
switch (msg.what) {
...
case DESTROY_ACTIVITY:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
handleDestroyActivity((IBinder) msg.obj, msg.arg1 != 0,
msg.arg2, false);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
Step19.ActivityThread.handleDestroyActivity
private void handleDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance) {
ActivityClientRecord r = performDestroyActivity(token, finishing,
configChanges, getNonConfigInstance);
...
if (finishing) {
try {
ActivityManagerNative.getDefault().activityDestroyed(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
mSomeActivitiesChanged = true;
}
Step20.ActivityThread.performDestroyActivity
private ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance) {
ActivityClientRecord r = mActivities.get(token);
Class<? extends Activity> activityClass = null;
if (localLOGV) Slog.v(TAG, "Performing finish of " + r);
if (r != null) {
...
performPauseActivityIfNeeded(r, "destroy");
...
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnDestroy(r.activity);
...
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
...
}
}
...
return r;
}
執(zhí)行performPauseActivityIfNeeded，然后執(zhí)行Instrumentation.callActivityOnDestroy方法結(jié)束。
Step21.ActivityThread.performPauseActivityIfNeeded
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
if (r.paused) {
// You are already paused silly...
return;
}
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnPause(r.activity);
...
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
...
}
r.paused = true;
}
如果已經(jīng)paused了，則直接返回，否則調(diào)用Instrumentation.callActivityOnPause方法。
Step22.Instrumentation.callActivityOnPause
public void callActivityOnPause(Activity activity) {
activity.performPause();
}
Step23.Activity.performPause
final void performPause() {
..
onPause();
...
}
Step24.Activity.onPause
protected void onPause() {
if (DEBUG_LIFECYCLE) Slog.v(TAG, "onPause " + this);
getApplication().dispatchActivityPaused(this);
mCalled = true;
}
這里就是調(diào)用了Activity的onPause方法了。
Step25.Activity.performStop
final void performStop(boolean preserveWindow) {
...
if (!mStopped) {
...
mCalled = false;
mInstrumentation.callActivityOnStop(this);
...
}
mResumed = false;
}
這里調(diào)用Instrumentation.callActivityOnStop方法，這里本來還有Fragment的處理，我略掉了，自己看看。
Step26.Instrumentation.callActivityOnStop
public void callActivityOnStop(Activity activity) {
activity.onStop();
}
這里調(diào)用了Activity的onStop方法。代碼略了。
Step28.Instrumentation.callActivityOnDestroy
public void callActivityOnDestroy(Activity activity) {
...
activity.performDestroy();
...
}
調(diào)用Activity的performDestroy方法
Step29.Activity.performDestroy
final void performDestroy() {
...
onDestroy();
...
}
這里終于看到了onDestroy方法。這里還有Fragment的處理，我沒有顯示出來，自己看看。我們再回到Step20中的第二個(gè)方法中。
Step31.AMP.activityDestroyed
public void activityDestroyed(IBinder token) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(token);
mRemote.transact(ACTIVITY_DESTROYED_TRANSACTION, data, reply, IBinder.FLAG_ONEWAY);
reply.readException();
data.recycle();
reply.recycle();
}
然后調(diào)用AMS中的activityDestroyed方法。
Step32.AMS.activityDestroyed
public final void activityDestroyed(IBinder token) {
synchronized (this) {
ActivityStack stack = ActivityRecord.getStackLocked(token);
if (stack != null) {
stack.activityDestroyedLocked(token, "activityDestroyed");
}
}
}
Step33.ActivityStack.activityDestroyedLocked
final void activityDestroyedLocked(IBinder token, String reason) {
final long origId = Binder.clearCallingIdentity();
try {
ActivityRecord r = ActivityRecord.forTokenLocked(token);
...
if (isInStackLocked(r) != null) {
if (r.state == ActivityState.DESTROYING) {
cleanUpActivityLocked(r, true, false);
removeActivityFromHistoryLocked(r, null, reason);
}
}
mStackSupervisor.resumeFocusedStackTopActivityLocked();
} finally {
Binder.restoreCallingIdentity(origId);
}
}
這里主要是兩步，第一個(gè)是調(diào)用cleanUpActivityLocked方法，清理Activity，前面Step12我們分析過了，不再分析。然后是調(diào)用removeActivityFromHistoryLocked方法，就是將該結(jié)束的Activity從歷史列表中刪除.
Step35.ActivityStack.removeActivityFromHistoryLocked
// 從歷史記錄移除
private void removeActivityFromHistoryLocked(
ActivityRecord r, TaskRecord oldTop, String reason) {
mStackSupervisor.removeChildActivityContainers(r);
finishActivityResultsLocked(r, Activity.RESULT_CANCELED, null);
...
if (task != null && task.removeActivity(r)) {
if (mStackSupervisor.isFocusedStack(this) && task == topTask &&
task.isOverHomeStack()) {
mStackSupervisor.moveHomeStackTaskToTop(task.getTaskToReturnTo(), reason);
}
removeTask(task, reason);
}
cleanUpActivityServicesLocked(r);
r.removeUriPermissionsLocked();
}
調(diào)用finishActivityResultsLocked方法處理Result，前面提到了。調(diào)用ActivityStackSupervisor.moveHomeStackTaskToTop將Home屬性的Activity所在任務(wù)棧放到頂部。調(diào)用cleanUpActivityServicesLocked清理綁定的服務(wù)。
Step39.ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
boolean resumeFocusedStackTopActivityLocked() {
return resumeFocusedStackTopActivityLocked(null, null, null);
}
這里我們在上一章Activity的啟動(dòng)時(shí)已經(jīng)分析過了。這里不再分析。到這里Activity的finish就分析完了，從這里我們主要學(xué)到的是finish的過程，以及finish過程中系統(tǒng)做了哪些處理，我們在寫代碼過程中應(yīng)該做那些處理。
流程圖：
ActivityFlow.jpg
代碼地址：
直接拉取導(dǎo)入開發(fā)工具（Intellij idea或者Android studio）
注
首發(fā)地址：http://www.codemx.cn
Android開發(fā)群：192508518
微信公眾賬號：Code-MX
注：本文原創(chuàng)，轉(zhuǎn)載請注明出處，多謝。
