"Turn" two minutes to fully understand the Android activity life cycle (graphics)!----good

Original URL: http://blog.csdn.net/android_tutor/article/details/5772285

Hello everyone, today to give you a detailed description of the activity of Android life cycle, I have said in front of this aspect of the content, but like most articles on the internet, basically are translated Android API, too general, I believe you see, there will be a little help, But it's not completely thoroughly understand, so I'm going to do it again today.

First look at the activity life cycle diagram provided in the Android API (not clear, you can see the full article, looking back at this diagram, you will understand):

The activity is actually inherited applicationcontext This class, we can rewrite the following method, the following code:

[Java]View Plaincopy

2. Public class Activity extends ApplicationContext {
4. protected void OnCreate (Bundle savedinstancestate);
8. protected void OnStart ();
12. protected void Onrestart ();
16. protected void Onresume ();
20. protected void OnPause ();
24. protected void OnStop ();
28. protected void OnDestroy ();
30. }

In order to facilitate the better understanding of everyone, I simply wrote a demo, do not understand the activity cycle of friends, you can practice, everyone follow my steps.

First step: Create a new Android project, which I named Activitydemo.

Step Two: Modify Activitydemo.java (I have re-written the above seven methods, mainly with log printing), the code is as follows:

[Java]View Plaincopy

2. Package Com.tutor.activitydemo;
4. Import android.app.Activity;
6. Import Android.os.Bundle;
8. Import Android.util.Log;
10. Public class Activitydemo extends Activity {
14. private static final String TAG = "Activitydemo";
18. public void OnCreate (Bundle savedinstancestate) {
20. super.oncreate (savedinstancestate);
22. Setcontentview (R.layout.main);
26. LOG.E (TAG, "Start oncreate~~~");
28. }
32. @Override
34. protected void OnStart () {
36. Super.onstart ();
38. LOG.E (TAG, "Start onstart~~~");
40. }
44. @Override
46. protected void Onrestart () {
48. Super.onrestart ();
50. LOG.E (TAG, "Start onrestart~~~");
52. }
56. @Override
58. protected void Onresume () {
60. Super.onresume ();
62. LOG.E (TAG, "Start onresume~~~");
64. }
68. @Override
70. protected void OnPause () {
72. Super.onpause ();
74. LOG.E (TAG, "Start onpause~~~");
76. }
80. @Override
82. protected void OnStop () {
84. Super.onstop ();
86. LOG.E (TAG, "Start onstop~~~");
88. }
92. @Override
94. protected void OnDestroy () {
96. Super.ondestroy ();
98. LOG.E (TAG, "Start ondestroy~~~");
100. }
104. }

Step three: Run the above project as follows (nothing special):

Core in Logcat window, if you do not use logcat you can take a look at my article Log text (LOG.V,LOG.D,LOG.I,LOG.W,LOG.E), we opened the application has been executed OnCreate () OnStart ()->onresume three methods, take a look at the Logcat window as follows:

Back key:

When we press the back key, our application will end, and this time we will call OnPause ()->onstop ()->ondestory () Three methods as shown:

Home key:

When we opened the app, like a browser, I was browsing the NBA news, and when I saw half of it, I suddenly wanted to listen to the song, and then we chose to press the home button to open the Music app, and when we pressed home, the activity executed OnPause (). OnStop () These two methods, the application is not destroyed at this time. As shown in the following:

When we start the Activitydemo application again, the Onrestart ()->onstart ()->onresume () Three methods are executed separately, as shown in:

Here we will draw a question, when we press the Home button, and then enter the Activitydemo application, our application status should be the same as the state before the home button, also for the convenience of understanding, here I will activitydemo code to make some changes, is to add a edittext.

Fourth step: Modify the Main.xml layout file (add a edittext), the code is as follows:

[Java]View Plaincopy

2. <?xml version="1.0" encoding="Utf-8"?>
4. <linearlayout xmlns:android="Http://schemas.android.com/apk/res/android"
6. android:orientation="Vertical"
8. Android:layout_width="Fill_parent"
10. android:layout_height="Fill_parent"
12. >
14. <textview
16. Android:layout_width="Fill_parent"
18. android:layout_height="Wrap_content"
20. android:text="@string/hello"
22. />
24. <edittext
26. android:id="@+id/edittext"
28. Android:layout_width="Fill_parent"
30. android:layout_height="Wrap_content"
32. />
34. </LinearLayout>

Fifth step: Then the other unchanged, run the Activitydemo program, enter in the EditText such as "Frankie" string (such as:)

At this time, you can press the Home button, and then start the Activitydemo application again, this time there is no edittext we entered the word "Frankie", such as:

This obviously cannot be called a qualified application, so we need to implement it ourselves in several methods of activity, as shown in the sixth step below:

The sixth step is to modify the Activitydemo.java code as follows:

[Java]View Plaincopy

2. Package Com.tutor.activitydemo;
4. Import android.app.Activity;
6. Import Android.os.Bundle;
8. Import Android.util.Log;
10. Import Android.widget.EditText;
12. Public class Activitydemo extends Activity {
16. private static final String TAG = "Activitydemo";
18. private EditText Medittext;
20. //define a String type to access the value of our edittext input
22. private String mstring;
24. public void OnCreate (Bundle savedinstancestate) {
26. super.oncreate (savedinstancestate);
28. Setcontentview (R.layout.main);
30. Medittext = (EditText) Findviewbyid (R.id.edittext);
32. LOG.E (TAG, "Start oncreate~~~");
34. }
38. @Override
40. protected void OnStart () {
42. Super.onstart ();
44. LOG.E (TAG, "Start onstart~~~");
46. }
48. //When you press the home key and then start the app again, we want to restore the previous state
50. @Override
52. protected void Onrestart () {
54. Super.onrestart ();
56. Medittext.settext (mstring);
58. LOG.E (TAG, "Start onrestart~~~");
60. }
64. @Override
66. protected void Onresume () {
68. Super.onresume ();
70. LOG.E (TAG, "Start onresume~~~");
72. }
76. //When we press the home key, I assign the input value to mstring in the OnPause method
78. @Override
80. protected void OnPause () {
82. Super.onpause ();
84. mstring = Medittext.gettext (). toString ();
86. LOG.E (TAG, "Start onpause~~~");
88. }
92. @Override
94. protected void OnStop () {
96. Super.onstop ();
98. LOG.E (TAG, "Start onstop~~~");
100. }
104. @Override
106. protected void OnDestroy () {
108. Super.ondestroy ();
110. LOG.E (TAG, "Start ondestroy~~~");
112. }
116. }

Seventh step: Rerun the Activitydemo program, repeat the fifth step, when we press the home key, when the application is launched again, EditText has the last input "Frankie" word, as shown:

OK, the basic Gaocheng, this time everyone can look at the activity life cycle diagram, I think we should fully understand the activity life cycle, do not know you know?

"Turn" two minutes to fully understand the Android activity life cycle (graphics)!----good