Activity的生命周期里的onStart和onStop

Activity的生命周期里的onStart与onResume的区别

• onStart函数的相关代码：

  /**
   * Called after {@link #onCreate} — or after {@link #onRestart} when
   * the activity had been stopped, but is now again being displayed to the
   * user.  It will be followed by {@link #onResume}.
   *
   * <p><em>Derived classes must call through to the super class's
   * implementation of this method.  If they do not, an exception will be
   * thrown.</em></p>
   *
   * @see #onCreate
   * @see #onStop
   * @see #onResume
   */
  protected void onStart() {
      if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this);
      mCalled = true;
  
      if (!mLoadersStarted) {
          mLoadersStarted = true;
          if (mLoaderManager != null) {
              mLoaderManager.doStart();
          } else if (!mCheckedForLoaderManager) {
              mLoaderManager = getLoaderManager("(root)", mLoadersStarted, false);
          }
          mCheckedForLoaderManager = true;
      }
  
      getApplication().dispatchActivityStarted(this);
  }
  

• onResume函数的相关代码

  /**
   * Called after {@link #onRestoreInstanceState}, {@link #onRestart}, or
   * {@link #onPause}, for your activity to start interacting with the user.
   * This is a good place to begin animations, open exclusive-access devices
   * (such as the camera), etc.
   *
   * <p>Keep in mind that onResume is not the best indicator that your activity
   * is visible to the user; a system window such as the keyguard may be in
   * front.  Use {@link #onWindowFocusChanged} to know for certain that your
   * activity is visible to the user (for example, to resume a game).
   *
   * <p><em>Derived classes must call through to the super class's
   * implementation of this method.  If they do not, an exception will be
   * thrown.</em></p>
   *
   * @see #onRestoreInstanceState
   * @see #onRestart
   * @see #onPostResume
   * @see #onPause
   */
  protected void onResume() {
      if (DEBUG_LIFECYCLE) Slog.v(TAG, "onResume " + this);
      getApplication().dispatchActivityResumed(this);
      mActivityTransitionState.onResume();
      mCalled = true;
  }
  

  从注释就可以看出来，onResume是执行在onStart函数之后的，onStart函数是执行在onCreate函数之后或者执行了onStop函数之后重新打开界面执行，onResume则是在执行了onStart或者onRestart或者onPause函数之后执行，在里面可以进行很多初始化工作，比如开始动画等等。。。他俩最大的不同，则是onStart是可见但用户不可对界面进行交互性操作的时刻，但是onResume则是不仅可见，也可与界面进行交互，并且界面会作出相应反应。

Activity的生命周期里的onStop与onPause的区别

• onStop函数的相关代码：

  /**
   * Called when you are no longer visible to the user.  You will next
   * receive either {@link #onRestart}, {@link #onDestroy}, or nothing,
   * depending on later user activity.
   *
   * <p>Note that this method may never be called, in low memory situations
   * where the system does not have enough memory to keep your activity's
   * process running after its {@link #onPause} method is called.
   *
   * <p><em>Derived classes must call through to the super class's
   * implementation of this method.  If they do not, an exception will be
   * thrown.</em></p>
   *
   * @see #onRestart
   * @see #onResume
   * @see #onSaveInstanceState
   * @see #onDestroy
   */
  protected void onStop() {
      if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStop " + this);
      if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(false);
      mActivityTransitionState.onStop();
      getApplication().dispatchActivityStopped(this);
      mTranslucentCallback = null;
      mCalled = true;
  }
  

• onPause函数的相关代码：

  /**
   * Called as part of the activity lifecycle when an activity is going into
   * the background, but has not (yet) been killed.  The counterpart to
   * {@link #onResume}.
   *
   * <p>When activity B is launched in front of activity A, this callback will
   * be invoked on A.  B will not be created until A's {@link #onPause} returns,
   * so be sure to not do anything lengthy here.
   *
   * <p>This callback is mostly used for saving any persistent state the
   * activity is editing, to present a "edit in place" model to the user and
   * making sure nothing is lost if there are not enough resources to start
   * the new activity without first killing this one.  This is also a good
   * place to do things like stop animations and other things that consume a
   * noticeable amount of CPU in order to make the switch to the next activity
   * as fast as possible, or to close resources that are exclusive access
   * such as the camera.
   *
   * <p>In situations where the system needs more memory it may kill paused
   * processes to reclaim resources.  Because of this, you should be sure
   * that all of your state is saved by the time you return from
   * this function.  In general {@link #onSaveInstanceState} is used to save
   * per-instance state in the activity and this method is used to store
   * global persistent data (in content providers, files, etc.)
   *
   * <p>After receiving this call you will usually receive a following call
   * to {@link #onStop} (after the next activity has been resumed and
   * displayed), however in some cases there will be a direct call back to
   * {@link #onResume} without going through the stopped state.
   *
   * <p><em>Derived classes must call through to the super class's
   * implementation of this method.  If they do not, an exception will be
   * thrown.</em></p>
   *
   * @see #onResume
   * @see #onSaveInstanceState
   * @see #onStop
   */
  protected void onPause() {
      if (DEBUG_LIFECYCLE) Slog.v(TAG, "onPause " + this);
      getApplication().dispatchActivityPaused(this);
      mCalled = true;
      }
  

  同样根据注释可以看出，onStop是在界面不再对用户可见的时候执行，而且在内存不足而导致系统无法保留此进程的情况下，onStop() 可能都不会被执行，但是可以执行一些耗时操作，因为是后台进程，不会对APP运行产生较大的影响；onPause也是在界面不可见的时候执行，但他就像onResume一样，与之对应，是执行动画取消，耗时或者耗费CPU的动作取消的好时机，但是不能够执行过于耗时的操作，因为要保证能快速完好的加载下一个界面。