学习整理——从安卓源码上看Activity

       安卓开发的四大组件是Activity, service, broadcast receiver, 和content provider。作为业余的开发者，可能不需要太深入理解这些组件的内部实现，以及运行机制。但是如果想要在这方面有所进阶的话，这些实现的源码还是要啃的。本文将从官方源码上讲一下对Activity的理解。

概述

定义

官方对Activity的开头描述为：

/**
An activity is a single, focused thing that the user can do. 
Almost all activities interact with the user, 
so the Activity class takes care of creating a window for you in which you can place your UI with setContentView(int). 
While activities are often presented to the user as full-screen windows, 
they can also be used in other ways: as floating windows (via a theme with android.R.attr set) 
or embedded inside of another activity (using ActivityGroup). 
There are two methods almost all subclasses of Activity will implement:
    onCreate(android.os.Bundle) is where you initialize your activity. 
    Most importantly, here you will usually call setContentView(int) with a layout resource defining your UI, 
    and using findViewById(int) to retrieve the widgets in that UI that you need to interact with programmatically.
    
    onPause() is where you deal with the user leaving your activity. 
    Most importantly, any changes made by the user should at this point be 
    committed (usually to the android.content.ContentProvider holding the data). 
**/

从安卓四大组件来看，Activity是唯一的可以与用户进行交互的组件，所以activity可以创建一个窗口并通过调用setContentView(int)来设定窗口的UI。

而且，Activity的表现形式不限于占据整个屏幕，还可以是一个悬浮窗口或者被嵌入到其他的Activity中。

Activity状态

接着再来看一个Acitivity的生命周期，虽然网上有很多对Activity生命周期的解释，但还是贴上源码上的注释：

/**
Activities in the system are managed as an activity stack. When a new activity is started, 
it is placed on the top of the stack and becomes the running activity -- the previous activity 
always remains below it in the stack, and will not come to the foreground again until the new activity exits.

An activity has essentially four states:
    1.If an activity in the foreground of the screen (at the top of the stack), it is active or running.
    2.If an activity has lost focus but is still visible (that is, a new non-full-sized or transparent activity
      has focus on top of your activity), it is paused. A paused activity is completely alive 
      (it maintains all state and member information and remains attached to the window manager), 
      but can be killed by the system in extreme low memory situations.
    3.If an activity is completely obscured by another activity, it is stopped. 
      It still retains all state and member information, however, 
      it is no longer visible to the user so its window is hidden and it will often be killed by the system 
      when memory is needed elsewhere.
    4.If an activity is paused or stopped, the system can drop the activity from memory by either asking it to finish, 
      or simply killing its process. When it is displayed again to the user, 
      it must be completely restarted and restored to its previous state.
**/

一个Activity的有四种状态，分别是：

1.Active或者running，当Activity处在前台，即屏幕的最前面时。

2.Paused，当Activity失去焦点但依然可见时，典型的情况是有个警告框弹出到屏幕的最前面。在这个状态下，Activity失去焦点不可接受用户的交互。当系统极端缺乏内存时，该Activity依然有可能被系统杀死。

3.Stopped，当Activity完全不可见后。

4.killed或者恢复，一个Activity处在paused或者stopped状态下，系统可以选择回收这个Activity的内存，进而杀死该Activity，或者在系统回收之前，用户重新将该Activity带到前台，进而恢复了它。要注意，系统的这种选择不受人为干预，所以开发要时刻注意Activity被杀死的情况。

生命周期类型

注释上还将Activity的生命周期按照特征分成了几种类型：

/**

    1.The entire lifetime of an activity happens between the first call to onCreate(android.os.Bundle) through 
      to a single final call to onDestroy(). An activity will do all setup of "global" state in onCreate(), 
      and release all remaining resources in onDestroy(). 
      For example, if it has a thread running in the background to download data from the network, 
      it may create that thread in onCreate() and then stop the thread in onDestroy().
    2.The visible lifetime of an activity happens between a call to onStart() until a corresponding call to onStop(). 
      During this time the user can see the activity on-screen, though it may not be in the foreground and interacting 
      with the user. Between these two methods you can maintain resources that are needed to show the activity to the user. 
      For example, you can register a android.content.BroadcastReceiver in onStart() to monitor for changes that 
      impact your UI, and unregister it in onStop() when the user no longer sees what you are displaying. 
      The onStart() and onStop() methods can be called multiple times, as the activity becomes visible and hidden to the user.
    3.The foreground lifetime of an activity happens between a call to onResume() until a corresponding call to onPause(). 
      During this time the activity is in front of all other activities and interacting with the user. 
      An activity can frequently go between the resumed and paused states -- for example when the device goes to sleep, 
      when an activity result is delivered, when a new intent is delivered -- 
      so the code in these methods should be fairly lightweight. 
**/

1.完整生命周期（entire lifetime），从一个Activity被创建分配内存到内存被系统回收。

2.可视生命周期（visible lifetime），成对出现的onStart()与onStop()之间的时间，能够为用户所见。

3.前台生命周期（foregroud lifetime）,成对出现的onResume()与onPause()之间的时间，能够为用户所见并交互。

通过上面的解释，不难得出网上随处可见Activity生命周期图表。

看着生命周期图，对照着官方注释，来看各个回调函数的源码

回调函数

onCreate

/**
Called when the activity is starting. 
This is where most initialization should go: calling setContentView(int) to inflate the activity's UI, 
using findViewById(int) to programmatically interact with widgets in the UI, 
calling managedQuery(android.net.Uri,java.lang.String[],java.lang.String,java.lang.String[],java.lang.String) to 
retrieve cursors for data being displayed, etc.
You can call finish() from within this function, 
in which case onDestroy() will be immediately called without any of the rest of the activity 
lifecycle (onStart(), onResume(), onPause(), etc) executing.

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.

Parameters:
    savedInstanceState If the activity is being re-initialized after previously 
    being shut down then this Bundle contains the data it most recently supplied in onSaveInstanceState(android.os.Bundle). 
    Note: Otherwise it is null.

**/
    protected void onCreate(@Nullable Bundle savedInstanceState) {

         if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);

         if (mLastNonConfigurationInstances != null) {

             mAllLoaderManagers = mLastNonConfigurationInstances.loaders;
         }
         if (mActivityInfo.parentActivityName != null) {
             if (mActionBar == null) {
                 mEnableDefaultActionBarUp = true;
             } else {
                 mActionBar.setDefaultDisplayHomeAsUpEnabled(true);
             }
         }
         if (savedInstanceState != null) {
             Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);
             mFragments.restoreAllState(p, mLastNonConfigurationInstances != null
                     ? mLastNonConfigurationInstances.fragments : null);
         }
         mFragments.dispatchCreate();
         getApplication().dispatchActivityCreated(this, savedInstanceState);
         if (mVoiceInteractor != null) {
             mVoiceInteractor.attachActivity(this);
         }
         mCalled = true;
     }

onStart

/**
Called after onCreate(android.os.Bundle) — or after onRestart() when the activity had been stopped, 
but is now again being displayed to the user. It will be followed by onResume().

Derived classes must call through to the super class's implementation of this method. 
If they do not, an exception will be thrown.
**/

    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 onRestoreInstanceState(android.os.Bundle), onRestart(), or 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.

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 onWindowFocusChanged(boolean) to know for certain that your activity is visible to the user (for example, to resume a game).

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.
**/

    protected void onResume() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onResume " + this);
        getApplication().dispatchActivityResumed(this);
        mActivityTransitionState.onResume();
        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 onResume().

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 onPause() returns, so be sure to not do anything lengthy here.

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.

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 onSaveInstanceState(android.os.Bundle) 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.)

After receiving this call you will usually receive a following call to onStop()
 (after the next activity has been resumed and displayed), 
however in some cases there will be a direct call back to onResume() without going through the stopped state.

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.
**/
    protected void onPause() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onPause " + this);
        getApplication().dispatchActivityPaused(this);
        mCalled = true;
    }

/**
Called when you are no longer visible to the user. You will next receive either onRestart(), onDestroy(), or nothing, 
depending on later user activity.

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 onPause() method is called.

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.
**/
    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;
    }

onStop

/**
Called after onStop() when the current activity is being re-displayed to the user (the user has navigated back to it). 
It will be followed by onStart() and then onResume().

For activities that are using raw android.database.Cursor objects 
(instead of creating them through managedQuery(android.net.Uri,java.lang.String[],java.lang.String,java.lang.String[],java.lang.String),
 this is usually the place where the cursor should be requeried (because you had deactivated it in onStop().

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.
**/

    protected void onRestart() {
        mCalled = true;
    }

当Activity将再次展示在前台时，系统将调用该方法。

onDestroy

/**
Perform any final cleanup before an activity is destroyed. 
This can happen either because the activity is finishing (someone called finish() on it, 
or because the system is temporarily destroying this instance of the activity to save space. 
You can distinguish between these two scenarios with the isFinishing() method.

Note: do not count on this method being called as a place for saving data! 
For example, if an activity is editing data in a content provider, those edits should be committed in either onPause() 
or onSaveInstanceState(android.os.Bundle), not here. 
This method is usually implemented to free resources like threads that are associated with an activity, 
so that a destroyed activity does not leave such things around while the rest of its application is still running.
There are situations where the system will simply kill the activity's hosting process without calling this method 
(or any others) in it, so it should not be used to do things that are intended to remain around after the process goes away.

Derived classes must call through to the super class's implementation of this method. If they do not, an exception will be thrown.
**/
    protected void onDestroy() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onDestroy " + this);
        mCalled = true;
        // dismiss any dialogs we are managing.

        if (mManagedDialogs != null) {
            final int numDialogs = mManagedDialogs.size();
            for (int i = 0; i < numDialogs; i++) {
                final ManagedDialog md = mManagedDialogs.valueAt(i);
                if (md.mDialog.isShowing()) {
                    md.mDialog.dismiss();
                }
            }
            mManagedDialogs = null;
        }

        // close any cursors we are managing.
        synchronized (mManagedCursors) {
            int numCursors = mManagedCursors.size();
            for (int i = 0; i < numCursors; i++) {
                ManagedCursor c = mManagedCursors.get(i);
                if (c != null) {
                    c.mCursor.close();
                }
            }
            mManagedCursors.clear();
        }
        // Close any open search dialog
        if (mSearchManager != null) {
            mSearchManager.stopSearch();
        }
        getApplication().dispatchActivityDestroyed(this);
    }

总结：

1.Activity生命周期的回调函数是系统在进行下一步操作前后调用的，以供开发者在各个阶段前后实现一些操作；

2.某些回调函数的父类实现比较简单，但都是打通一个Activity生命周期的重要操作。所以为了保持Activity的一致性，避免开发者不理解整一个生命周期原理，Android强制要求在重写这些回调函数时需要调用父类实现；

3.Activity的生命周期中onCreate()只会调用一次，需要适合一个全局变量的赋值，监听函数的设定，而onStart()和onResume()可能会被多次调用，所以不适合在方法里创建对象，因为调用一次，之前的对象就是成了垃圾。垃圾多了，对程序对系统都不是一件好事；

4.某些情况下，系统可以越过onStop()和onDestroy()而直接杀死Activity，所以一些重要信息的保存要放在onPause()里；

5.Activity的运作原理就是系统对各种回调函数的调用，开发者无法控制一个Activity的生命周期，但可以在其生命周期中定制一些实现，让其能够按照定义一般运行下去；

5.在Activity里可以找到很多函数，最大程序上保证了一个Activity能够实现的工程，这表示了一个系统多么精巧而缜密的。比如一个onKeyDown()回调函数，用以监测一个用户的输入情况。但按键的监测也是一个系统行为，它会按照传递等级一层一层地将输入情况向下传递，如果输入在某一层得到处理，返回true以表示让系统不再将输入情况向下传递，返回false则表示在这层没得到处理，系统可以继续向下传递。等等。

原文：http://blog.csdn.net/jeffery_gong/article/details/51260524