Activity 的生命周期

package com.example.activity;import android.app.Activity;import android.content.res.Configuration;import android.net.Uri;import android.os.Bundle;import android.util.Log;import android.view.View;public class MainActivity extends Activity {private static final String TAG = "MainActivity";/** * Called when the activity is starting.  This is where most initialization * should go: calling {@link #setContentView(int)} to inflate the * activity's UI, using {@link #findViewById} to programmatically interact * with widgets in the UI, calling * {@link #managedQuery(android.net.Uri , String[], String, String[], String)} to retrieve * cursors for data being displayed, etc. *  * <p>You can call {@link #finish} from within this function, in * which case onDestroy() will be immediately called without any of the rest * of the activity lifecycle ({@link #onStart}, {@link #onResume}, * {@link #onPause}, etc) executing. *  * <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> *  * @param savedInstanceState If the activity is being re-initialized after *     previously being shut down then this Bundle contains the data it most *     recently supplied in {@link #onSaveInstanceState}.  <b><i>Note: Otherwise it is null.</i></b> *  * @see #onStart * @see #onSaveInstanceState * @see #onRestoreInstanceState * @see #onPostCreate */@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Log.v(TAG, "onCreate");}/** * 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/> * <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 */@Overrideprotected void onStart() {super.onStart();Log.v(TAG, "onStart");}/** * Called after {@link #onStop} when the current activity is being * re-displayed to the user (the user has navigated back to it).  It will * be followed by {@link #onStart} and then {@link #onResume}. * <p/> * <p>For activities that are using raw {@link Cursor} objects (instead of * creating them through * {@link #managedQuery(Uri, String[], String, String[], String)}, * this is usually the place * where the cursor should be requeried (because you had deactivated it in * {@link #onStop}. * <p/> * <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 #onStop * @see #onStart * @see #onResume */@Overrideprotected void onRestart() {super.onRestart();Log.v(TAG, "onRestart");}/** * 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/> * <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/> * <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 */@Overrideprotected void onResume() {super.onResume();Log.v(TAG, "onResume");}/** * Called to retrieve per-instance state from an activity before being killed * so that the state can be restored in {@link #onCreate} or * {@link #onRestoreInstanceState} (the {@link Bundle} populated by this method * will be passed to both). * <p/> * <p>This method is called before an activity may be killed so that when it * comes back some time in the future it can restore its state.  For example, * if activity B is launched in front of activity A, and at some point activity * A is killed to reclaim resources, activity A will have a chance to save the * current state of its user interface via this method so that when the user * returns to activity A, the state of the user interface can be restored * via {@link #onCreate} or {@link #onRestoreInstanceState}. * <p/> * <p>Do not confuse this method with activity lifecycle callbacks such as * {@link #onPause}, which is always called when an activity is being placed * in the background or on its way to destruction, or {@link #onStop} which * is called before destruction.  One example of when {@link #onPause} and * {@link #onStop} is called and not this method is when a user navigates back * from activity B to activity A: there is no need to call {@link #onSaveInstanceState} * on B because that particular instance will never be restored, so the * system avoids calling it.  An example when {@link #onPause} is called and * not {@link #onSaveInstanceState} is when activity B is launched in front of activity A: * the system may avoid calling {@link #onSaveInstanceState} on activity A if it isn't * killed during the lifetime of B since the state of the user interface of * A will stay intact. * <p/> * <p>The default implementation takes care of most of the UI per-instance * state for you by calling {@link View#onSaveInstanceState()} on each * view in the hierarchy that has an id, and by saving the id of the currently * focused view (all of which is restored by the default implementation of * {@link #onRestoreInstanceState}).  If you override this method to save additional * information not captured by each individual view, you will likely want to * call through to the default implementation, otherwise be prepared to save * all of the state of each view yourself. * <p/> * <p>If called, this method will occur before {@link #onStop}.  There are * no guarantees about whether it will occur before or after {@link #onPause}. * * @param outState Bundle in which to place your saved state. * @see #onCreate * @see #onRestoreInstanceState * @see #onPause */@Overrideprotected void onSaveInstanceState(Bundle outState) {super.onSaveInstanceState(outState);Log.v(TAG, "onSaveInstanceState");}/** * This method is called after {@link #onStart} when the activity is * being re-initialized from a previously saved state, given here in * <var>savedInstanceState</var>.  Most implementations will simply use {@link #onCreate} * to restore their state, but it is sometimes convenient to do it here * after all of the initialization has been done or to allow subclasses to * decide whether to use your default implementation.  The default * implementation of this method performs a restore of any view state that * had previously been frozen by {@link #onSaveInstanceState}. *  * <p>This method is called between {@link #onStart} and * {@link #onPostCreate}. *  * @param savedInstanceState the data most recently supplied in {@link #onSaveInstanceState}. *  * @see #onCreate * @see #onPostCreate * @see #onResume * @see #onSaveInstanceState */@Overrideprotected void onRestoreInstanceState(Bundle savedInstanceState) {super.onRestoreInstanceState(savedInstanceState);Log.v(TAG, "onRestoreInstanceState");}/** * 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/> * <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/> * <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/> * <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/> * <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/> * <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 */@Overrideprotected void onPause() {super.onPause();Log.v(TAG, "onPause");}/** * 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/> * <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/> * <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 */@Overrideprotected void onStop() {super.onStop();Log.v(TAG, "onStop");}/** * Perform any final cleanup before an activity is destroyed.  This can * happen either because the activity is finishing (someone called * {@link #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 {@link #isFinishing} method. * <p/> * <p><em>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 {@link #onPause} or * {@link #onSaveInstanceState}, not here.</em> 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. * <p/> * <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 #onPause * @see #onStop * @see #finish * @see #isFinishing */@Overrideprotected void onDestroy() {super.onDestroy();Log.v(TAG, "onDestroy");}/** * Called by the system when the device configuration changes while your * activity is running.  Note that this will <em>only</em> be called if * you have selected configurations you would like to handle with the * {@link android.R.attr#configChanges} attribute in your manifest.  If * any configuration change occurs that is not selected to be reported * by that attribute, then instead of reporting it the system will stop * and restart the activity (to have it launched with the new * configuration). * <p/> * <p>At the time that this function has been called, your Resources * object will have been updated to return resource values matching the * new configuration. * * @param newConfig The new device configuration. */@Overridepublic void onConfigurationChanged(Configuration newConfig) {super.onConfigurationChanged(newConfig);Log.v(TAG,"onConfigurationChanged");}}

-------------------------------------------------------
启动APP时
-------------------------------------------------------
07-31 10:54:57.294: V/MainActivity(17366): onCreate
07-31 10:54:57.294: V/MainActivity(17366): onStart
07-31 10:54:57.294: V/MainActivity(17366): onResume
-------------------------------------------------------
Power键 或 Home键
-------------------------------------------------------
07-31 10:55:57.934: V/MainActivity(17366): onPause
07-31 10:55:58.004: V/MainActivity(17366): onSaveInstanceState
07-31 10:55:58.004: V/MainActivity(17366): onStop
-------------------------------------------------------
再次Power键 或 导航返回该Activity
-------------------------------------------------------
07-31 10:56:16.294: V/MainActivity(17366): onRestart
07-31 10:56:16.304: V/MainActivity(17366): onStart
07-31 10:56:16.314: V/MainActivity(17366): onResume
Back键退出
-------------------------------------------------------
07-31 10:56:33.134: V/MainActivity(17366): onPause
07-31 10:56:33.974: V/MainActivity(17366): onStop
07-31 10:56:33.974: V/MainActivity(17366): onDestroy
-------------------------------------------------------
旋转屏幕 没有配置 onConfigChanged
-------------------------------------------------------
07-31 13:42:42.919: V/MainActivity(20300): onPause
07-31 13:42:42.919: V/MainActivity(20300): onSaveInstanceState
07-31 13:42:42.919: V/MainActivity(20300): onStop
07-31 13:42:42.919: V/MainActivity(20300): onDestroy
07-31 13:42:42.999: V/MainActivity(20300): onCreate
07-31 13:42:42.999: V/MainActivity(20300): onStart
07-31 13:55:05.349: V/MainActivity(23582): onRestoreInstanceState
07-31 13:42:42.999: V/MainActivity(20300): onResume
-------------------------------------------------------
android:configChanges="orientation|screenSize"
-------------------------------------------------------
07-31 13:47:04.359: V/MainActivity(22637): onConfigurationChanged
-------------------------------------------------------