详解Android.activity销毁流程的工作原理

public void finish() {
 finish(false);
}

private void finish(Boolean finishTask) {
  if (mParent == null) {
   int resultCode;
   Intent resultData;
   synchronized (this) {
    resultCode = mResultCode;
    resultData = mResultData;
   }
   if (false) Log.v(tag,"Finishing self: token=" + mToken);
   try {
    if (resultData != null) {
     resultData.prepareToLeaveProcess();
    }
    if (ActivitymanagerNative.getDefault()
      .finishActivity(mToken,resultCode,resultData,finishTask)) {
     mFinished = true;
    }
   } catch (remoteexception E) {
    // Empty
   }
  } else {
   mParent.finishFromChild(this);
  }
 }

@Override
public final Boolean finishActivity(IBinder token,int resultCode,Intent resultData,Boolean finishTask) {
  ...
  res = tr.stack.requestFinishActivityLocked(token,"app-request",truE);
  ...
}

final Boolean requestFinishActivityLocked(IBinder token,String reason,Boolean oomAdj) {
  ActivityRecord r = isInStackLocked(token);
  if (DEBUG_RESULTS || DEBUG_STATES) Slog.v(tag_STATES,"Finishing activity token=" + token + " r="
    + ",result=" + resultCode + ",data=" + resultData
    + ",reason=" + reason);
  if (r == null) {
   return false;
  }

  finishActivityLocked(r,reason,oomAdj);
  return true;
 }

final Boolean finishActivityLocked(ActivityRecord r,Boolean oomAdj) {
  ...
  startPausingLocked(false,false,falsE);
  ...
  return false;
 }

final Boolean startPausingLocked(Boolean userLeaving,Boolean uiSleeping,Boolean resuming,Boolean dontWait) {
  ...
   try {
    EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,prev.userId,System.identityHashCode(prev),prev.shortComponentName);
    mservice.updateUsageStats(prev,falsE);
    prev.app.thread.schedulePauseActivity(prev.appToken,prev.finishing,userLeaving,prev.configChangeFlags,dontWait);
   } catch (Exception E) {
    // Ignore exception,if process died other code will cleanup.
    Slog.w(tag,"Exception thrown during pause",E);
    mPausingActivity = null;
    mLastPausedActivity = null;
    mLastNoHistoryActivity = null;
   }
  ...
 }

public final void schedulePauseActivity(IBinder token,Boolean finished,Boolean userLeaving,int configChanges,Boolean dontReport) {
 sendmessage(
  finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,token,(userLeaving ? 1 : 0) | (dontReport ? 2 : 0),configChanges);
}

private void sendmessage(int what,Object obj,int arg1,int arg2) {
  sendmessage(what,obj,arg1,arg2,falsE);
 }

private void sendmessage(int what,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);
 }

private void handlePauseActivity(IBinder token,Boolean dontReport) {
  ActivityClientRecord r = mActivities.get(token);
  if (r != null) {
   //Slog.v(tag,"userLeaving=" + userLeaving + " handling pause of " + r);
   if (userLeaving) {
    performUserLeavingActivity(r);
   }

   r.activity.mConfigChangeFlags |= configChanges;
   performPauseActivity(token,finished,r.isPreHoneycomb());

   // Make sure any pending writes are Now committed.
   if (r.isPreHoneycomb()) {
    QueuedWork.waitToFinish();
   }

   // Tell the activity manager we have paused.
   if (!dontReport) {
    try {
     ActivitymanagerNative.getDefault().activityPaused(token);
    } catch (remoteexception eX) {
    }
   }
   mSomeActivitiesChanged = true;
  }
 }

@Override
 public final void activityPaused(IBinder token) {
  final long origId = Binder.clearCallingIdentity();
  synchronized(this) {
   ActivityStack stack = ActivityRecord.getStackLocked(token);
   if (stack != null) {
    stack.activityPausedLocked(token,falsE);
   }
  }
  Binder.restoreCallingIdentity(origId);
 }

final void activityPausedLocked(IBinder token,Boolean timeout) {
  ...
  completePauseLocked(true);
  ...
}

private void completePauseLocked(Boolean resumeNext) {
 ...     mStackSupervisor.resumeTopActivitiesLocked(topStack,null,null);
 ...
 }

private class Idler implements messageQueue.IdleHandler {
  @Override
  public final Boolean queuEIDle() {
   ActivityClientRecord a = mNewActivities;
   Boolean stopProfiling = false;
   if (mBoundApplication != null && mProfiler.profileFd != null
     && mProfiler.autoStopProfiler) {
    stopProfiling = true;
   }
   if (a != null) {
    mNewActivities = null;
    IActivitymanager am = ActivitymanagerNative.getDefault();
    ActivityClientRecord prev;
    do {
     if (LOCALLOGV) Slog.v(
      TAG,"ReporTing idle of " + a +
      " finished=" +
      (a.activity != null && a.activity.mFinished));
     if (a.activity != null && !a.activity.mFinished) {
      try {
       am.activityIdle(a.token,a.createdConfig,stopProfiling);
       a.createdConfig = null;
      } catch (remoteexception eX) {
       // Ignore
      }
     }
     prev = a;
     a = a.nextIdle;
     prev.nextIdle = null;
    } while (a != null);
   }
   if (stopProfiling) {
    mProfiler.stopProfiling();
   }
   ensureJitEnabled();
   return false;
  }
 }

public final void activityIdle(IBinder token,Configuration config,Boolean stopProfiling) {
  final long origId = Binder.clearCallingIdentity();
  synchronized (this) {
   ActivityStack stack = ActivityRecord.getStackLocked(token);
   if (stack != null) {
    ActivityRecord r =
      mStackSupervisor.activityIdleInternalLocked(token,config);
    if (stopProfiling) {
     if ((mProfileProc == r.app) && (mProfileFd != null)) {
      try {
       mProfileFd.close();
      } catch (IOException E) {
      }
      clearProfilerLocked();
     }
    }
   }
  }
  Binder.restoreCallingIdentity(origId);
 }

final ActivityRecord activityIdleInternalLocked(final IBinder token,Boolean fromTimeout,Configuration config) {
 .... 
 stack.destroyActivityLocked(r,true,"finish-idle");
 .... 
}

final Boolean destroyActivityLocked(ActivityRecord r,Boolean removeFromApp,String reason) {
  ...
  r.app.thread.scheduleDestroyActivity(r.appToken,r.finishing,r.configChangeFlags);
  ...  
}

public final void scheduleDestroyActivity(IBinder token,Boolean finishing,int configChanges) {
 sendmessage(H.DESTROY_ACTIVITY,finishing ? 1 : 0,configChanges);
}

private void handleDestroyActivity(IBinder token,Boolean getNonConfigInstancE) {
  ActivityClientRecord r = performDestroyActivity(token,finishing,configChanges,getNonConfigInstancE);
  if (r != null) {
   cleanUpPendingRemoveWindows(r);
   WindowManager wm = r.activity.getWindowManager();
   View v = r.activity.mDecor;
   if (v != null) {
    if (r.activity.mVisibleFromServer) {
     mNumVisibleActivities--;
    }
    IBinder wtoken = v.getWindowToken();
    if (r.activity.mWindowAdded) {
     if (r.onlyLocalrequest) {
      // Hold off on removing this until the new activity's
      // window is being added.
      r.mPendingRemoveWindow = v;
      r.mPendingRemoveWindowManager = wm;
     } else {
      wm.removeViewImmediate(v);
     }
    }
    if (wtoken != null && r.mPendingRemoveWindow == null) {
     WindowManagerGlobal.geTinstance().closeAll(wtoken,r.activity.getClass().getName(),"Activity");
    }
    r.activity.mDecor = null;
   }
   if (r.mPendingRemoveWindow == null) {
    // If we are delaying the removal of the activity window,then
    // we can't clean up all windows here. Note that we can't do
    // so later either,which means any windows that aren't closed
    // by the app will leak. Well we try to warning them a lot
    // about leaking windows,because that is a bug,so if they are
    // using this recreate facility then they get to live with leaks.
    WindowManagerGlobal.geTinstance().closeAll(token,"Activity");
   }

   // mocked out contexts won't be participaTing in the normal
   // process lifecycle,but if we're running with a proper
   // ApplicationContext we need to have it tear down things
   // cleanly.
   Context c = r.activity.getBaseContext();
   if (c instanceof ContextImpl) {
    ((ContextImpl) C).scheduleFinalCleanup(
      r.activity.getClass().getName(),"Activity");
   }
  }
  if (finishing) {
   try {
    ActivitymanagerNative.getDefault().activityDestroyed(token);
   } catch (remoteexception eX) {
    // If the system process has died,it's game over for everyone.
   }
  }
  mSomeActivitiesChanged = true;
 }

private ActivityClientRecord performDestroyActivity(IBinder token,Boolean getNonConfigInstancE) {
  ...  
  r.activity.performStop();
  ...
  minstrumentation.callActivityOnDestroy(r.activity);
  ...
 }

final void performStop() {
  ...
  minstrumentation.callActivityOnStop(this);
  ...
}

public void callActivityOnStop(Activity activity) {
  activity.onStop();
 }

public void callActivityOnDestroy(Activity activity) {
 ...
 activity.performDestroy();
 ...
}

final void performDestroy() {
  mDestroyed = true;
  mWindow.destroy();
  mFragments.dispatchDestroy();
  onDestroy();
  mFragments.doLoaderDestroy();
  if (mVoiceInteractor != null) {
   mVoiceInteractor.detachActivity();
  }
 }