昊仔

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
理解Activity的生命周期

理解Activity的生命周期非常重要，系统(Framework)会通过钩子函数(onCreate() onStart() onPause() onResume() onStop() onDestroy() onRestart())来告诉我们当前Activity所在生命周期的哪个状态，我们可以在特定的状态完成相应的操作。

 

本文尽量用通俗易懂的语言描述Activity的生命周期，如果说得不好，请大家批评指正。

在这里，我们先设计几个场景，看看在不同的场景下，Activity的生命周期函数时如何被调用的。

场景一：启动一个Activity，然后按Back键退出应用

Activity的代码如下：

 

[java] view plaincopyprint?
  1. package com.zhuozhuo; 
  2.  
  3. import android.app.Activity; 
  4. import android.app.AlertDialog; 
  5. import android.app.Dialog; 
  6. import android.content.Intent; 
  7. import android.os.Bundle; 
  8. import android.os.Debug; 
  9. import android.util.Log; 
  10. import android.view.View; 
  11. import android.view.View.OnClickListener; 
  12.  
  13. publicclass ActivityA extends Activity { 
  14.     /** Called when the activity is first created. */ 
  15.     @Override 
  16.     publicvoid onCreate(Bundle savedInstanceState) { 
  17.         super.onCreate(savedInstanceState); 
  18.         Util.log("onCreate()"); 
  19.         setContentView(R.layout.main); 
  20.  
  21.     } 
  22.      
  23.      
  24.     //在onCreate()或onRestart()之后调用  
  25.     @Override 
  26.     publicvoid onStart() { 
  27.         super.onStart(); 
  28.          
  29.         Util.log("onStart()"); 
  30.     } 
  31.      
  32.     //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用  
  33.     //在这里可以开始动画，打开外部设备(camera等)  
  34.     //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见  
  35.     @Override 
  36.     publicvoid onResume() { 
  37.         super.onResume(); 
  38.         Util.log("onResume()"); 
  39.     } 
  40.      
  41.     //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点  
  42.     //当activity将要被遮挡时调用  
  43.     //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）  
  44.     //这里停止那些占用cpu时间的任务，如动画，camera等  
  45.     //对比onSaveInstanceState(Bundle):  
  46.     //onSaveInstanceState(Bundle) 实现保存activity实例的状态  
  47.     //而onPause()可以保存全局的持久化数据(content providers,files等)  
  48.     @Override 
  49.     publicvoid onPause() { 
  50.         super.onPause(); 
  51.         Util.log("onPause()"); 
  52.     } 
  53.      
  54.  
  55.     //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收  
  56.     @Override 
  57.     publicvoid onStop() { 
  58.         super.onStop(); 
  59.         Util.log("onStop()"); 
  60.     } 
  61.      
  62.     //在activity销毁之前处理  
  63.     @Override 
  64.     publicvoid onDestroy() { 
  65.         super.onDestroy(); 
  66.         Util.log("onDestroy()"); 
  67.     } 
  68.      
  69.   //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据  
  70.      
  71.     @Override 
  72.     protectedvoid onSaveInstanceState (Bundle outState) { 
  73.         super.onSaveInstanceState(outState); 
  74.         outState.putString("key", "value"); 
  75.         Util.log("onSaveInstanceState() outState:" + outState); 
  76.     } 
  77.      
  78.     //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）  
  79.     @Override 
  80.     protectedvoid onRestoreInstanceState (Bundle savedInstanceState) { 
  81.         super.onRestoreInstanceState(savedInstanceState); 
  82.         Util.log("onRestoreInstanceState() savedInstanceState:" + savedInstanceState); 
  83.     } 
  84.      
  85.      
  86.     //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）  
  87.     @Override 
  88.     protectedvoid onRestart() { 
  89.         super.onRestart(); 
  90.         Util.log("onRestart()"); 
  91.     } 
  92.         
  93.      
  94. }  
package com.zhuozhuo;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Intent;
import android.os.Bundle;
import android.os.Debug;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;

public class ActivityA extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Util.log("onCreate()");
        setContentView(R.layout.main);

    }
    
    
    //在onCreate()或onRestart()之后调用
    @Override
    public void onStart() {
    	super.onStart();
    	
    	Util.log("onStart()");
    }
    
    //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用
    //在这里可以开始动画，打开外部设备(camera等)
    //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见
    @Override
    public void onResume() {
    	super.onResume();
    	Util.log("onResume()");
    }
    
    //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点
    //当activity将要被遮挡时调用
    //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）
    //这里停止那些占用cpu时间的任务，如动画，camera等
    //对比onSaveInstanceState(Bundle):
    //onSaveInstanceState(Bundle) 实现保存activity实例的状态
    //而onPause()可以保存全局的持久化数据(content providers,files等)
    @Override
    public void onPause() {
    	super.onPause();
    	Util.log("onPause()");
    }
    

    //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收
    @Override
    public void onStop() {
    	super.onStop();
    	Util.log("onStop()");
    }
    
    //在activity销毁之前处理
    @Override
    public void onDestroy() {
    	super.onDestroy();
    	Util.log("onDestroy()");
    }
    
  //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据
    
    @Override
    protected void onSaveInstanceState (Bundle outState) {
    	super.onSaveInstanceState(outState);
    	outState.putString("key", "value");
    	Util.log("onSaveInstanceState() outState:" + outState);
    }
    
    //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）
    @Override
    protected void onRestoreInstanceState (Bundle savedInstanceState) {
    	super.onRestoreInstanceState(savedInstanceState);
    	Util.log("onRestoreInstanceState() savedInstanceState:" + savedInstanceState);
    }
    
    
    //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）
    @Override
    protected void onRestart() {
    	super.onRestart();
    	Util.log("onRestart()");
    }
       
    
}

 

log打印信息如下：

 

在这种场景下Activity的经过了下面六种生命状态onCreate --> onStart --> onResume --> onPause --> onStop --> onDestroy

 

场景一解释：

1、系统（framework）在启动Activity的时候会初始化一些运行时变量，当初始化完成后，会调用Activity的onCreate(Bundle savedInstanceState),相当于他告知Activity：“我帮你搭建好环境了，你现在开始创建吧”

onCreate(Bundle savedInstanceState):从log信息中我们得知，Activity启动的时候首先会调用onCreate()方法，这时候，Activity被告知要做一些初始化的工作，在这个方法里，Activity的UI元素还没绘到界面上，我们需要调用setContentView()来设定Activity的布局，另外，我们经常做的事情就是使用findViewById()初始化类中的Ui成员。

onCreate(Bundle savedInstanceState)中有一个参数savedInstanceState，是用来恢复活动状态的，具体的用法我们在场景二中会提到。

2、当Activity创建完毕后，系统就急不及待要把Activity显示出来，在显示出来之前，他会问Activity:"你要显示出来了，你还要做些什么准备工作么？"，此时会调用onStart()函数

Activity在将要显示出来之前被调用，如果你需要动态注册一个BroadcastReceiver，那么建议在这里进行注册。

3、然后系统会让Activity显示出来（但也有可能被系统窗口阻挡），然后问Activity:"我尽力把你显示出来了，你有什么事没做的自己看着办吧"，此时调用onResume

在这里可以开始动画，打开外部设备(camera等)注意这个方法并无意味着Activity是可见的，Activity还有可能被系统窗口遮挡（如：锁屏界面，输入法等），使用onWindowFocusChanged(boolean)来确认window是否可见

4、用户按Back键后，系统会先暂停Activity，然后再销毁Activity，它相当于告知Activity：“我要暂停你了，你有什么要说的吗”，此时调用onPause

当activity将要被遮挡时调用在此应该完成一些轻量级的数据持久化处理（因为只有此方法return后，新的activity才会被显示出来，如果被繁重的工作阻塞了ui线程，那么新的Activity将不会被显示出来）这里停止那些占用cpu时间的任务，如动画，camera等

5、暂停之后系统就把Activity设为不可见，它告知Activity：“大家都看不到你了，还要说几句吗？”，此时调用onStop

如果在onStart()中动态注册了一个BroadcastReceiver，那么就在onStop()处取消注册。如果使用了cursor，就在这里关闭cursor，释放资源

6、系统准备销毁Activity，此时它对Activity说：“哈哈，你要挂了，有什么遗言就说吧”,此时调用onDestroy

 

场景二：启动一个Activity A，然后点击按钮再打开另外一个Activity B，最后按back键返回到Activity A

Activity A

的代码如下：

 

[java] view plaincopyprint?
  1. package com.zhuozhuo; 
  2.  
  3. import android.app.Activity; 
  4. import android.app.AlertDialog; 
  5. import android.app.Dialog; 
  6. import android.content.Intent; 
  7. import android.os.Bundle; 
  8. import android.os.Debug; 
  9. import android.util.Log; 
  10. import android.view.View; 
  11. import android.view.View.OnClickListener; 
  12.  
  13. publicclass ActivityA extends Activity { 
  14.     /** Called when the activity is first created. */ 
  15.     @Override 
  16.     publicvoid onCreate(Bundle savedInstanceState) { 
  17.         super.onCreate(savedInstanceState); 
  18.         Util.log("Activity A onCreate()"); 
  19.         setContentView(R.layout.main); 
  20.         findViewById(R.id.button1).setOnClickListener(new OnClickListener() { 
  21.              
  22.             publicvoid onClick(View v) { 
  23.                 startActivity(new Intent(getApplicationContext(),ActivityB.class)); 
  24.             } 
  25.         }); 
  26.  
  27.     } 
  28.      
  29.      
  30.     //在onCreate()或onRestart()之后调用  
  31.     @Override 
  32.     publicvoid onStart() { 
  33.         super.onStart(); 
  34.          
  35.         Util.log("Activity A onStart()"); 
  36.     } 
  37.      
  38.     //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用  
  39.     //在这里可以开始动画，打开外部设备(camera等)  
  40.     //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见  
  41.     @Override 
  42.     publicvoid onResume() { 
  43.         super.onResume(); 
  44.         Util.log("Activity A onResume()"); 
  45.     } 
  46.      
  47.     //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点  
  48.     //当activity将要被遮挡时调用  
  49.     //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）  
  50.     //这里停止那些占用cpu时间的任务，如动画，camera等  
  51.     //对比onSaveInstanceState(Bundle):  
  52.     //onSaveInstanceState(Bundle) 实现保存activity实例的状态  
  53.     //而onPause()可以保存全局的持久化数据(content providers,files等)  
  54.     @Override 
  55.     publicvoid onPause() { 
  56.         super.onPause(); 
  57.         Util.log("Activity A onPause()"); 
  58.     } 
  59.      
  60.  
  61.     //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收  
  62.     @Override 
  63.     publicvoid onStop() { 
  64.         super.onStop(); 
  65.         Util.log("Activity A onStop()"); 
  66.     } 
  67.      
  68.     //在activity销毁之前处理  
  69.     @Override 
  70.     publicvoid onDestroy() { 
  71.         super.onDestroy(); 
  72.         Util.log("Activity A onDestroy()"); 
  73.     } 
  74.      
  75.   //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据  
  76.      
  77.     @Override 
  78.     protectedvoid onSaveInstanceState (Bundle outState) { 
  79.         super.onSaveInstanceState(outState); 
  80.         outState.putString("key", "value"); 
  81.         Util.log("Activity A onSaveInstanceState() outState:" + outState); 
  82.     } 
  83.      
  84.     //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）  
  85.     @Override 
  86.     protectedvoid onRestoreInstanceState (Bundle savedInstanceState) { 
  87.         super.onRestoreInstanceState(savedInstanceState); 
  88.         Util.log("Activity A onRestoreInstanceState() savedInstanceState:" + savedInstanceState); 
  89.     } 
  90.      
  91.      
  92.     //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）  
  93.     @Override 
  94.     protectedvoid onRestart() { 
  95.         super.onRestart(); 
  96.         Util.log("Activity A onRestart()"); 
  97.     } 
  98.      
  99.  
  100. }  
package com.zhuozhuo;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Intent;
import android.os.Bundle;
import android.os.Debug;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;

public class ActivityA extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Util.log("Activity A onCreate()");
        setContentView(R.layout.main);
        findViewById(R.id.button1).setOnClickListener(new OnClickListener() {
			
			public void onClick(View v) {
				startActivity(new Intent(getApplicationContext(),ActivityB.class));
			}
		});

    }
    
    
    //在onCreate()或onRestart()之后调用
    @Override
    public void onStart() {
    	super.onStart();
    	
    	Util.log("Activity A onStart()");
    }
    
    //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用
    //在这里可以开始动画，打开外部设备(camera等)
    //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见
    @Override
    public void onResume() {
    	super.onResume();
    	Util.log("Activity A onResume()");
    }
    
    //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点
    //当activity将要被遮挡时调用
    //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）
    //这里停止那些占用cpu时间的任务，如动画，camera等
    //对比onSaveInstanceState(Bundle):
    //onSaveInstanceState(Bundle) 实现保存activity实例的状态
    //而onPause()可以保存全局的持久化数据(content providers,files等)
    @Override
    public void onPause() {
    	super.onPause();
    	Util.log("Activity A onPause()");
    }
    

    //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收
    @Override
    public void onStop() {
    	super.onStop();
    	Util.log("Activity A onStop()");
    }
    
    //在activity销毁之前处理
    @Override
    public void onDestroy() {
    	super.onDestroy();
    	Util.log("Activity A onDestroy()");
    }
    
  //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据
    
    @Override
    protected void onSaveInstanceState (Bundle outState) {
    	super.onSaveInstanceState(outState);
    	outState.putString("key", "value");
    	Util.log("Activity A onSaveInstanceState() outState:" + outState);
    }
    
    //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）
    @Override
    protected void onRestoreInstanceState (Bundle savedInstanceState) {
    	super.onRestoreInstanceState(savedInstanceState);
    	Util.log("Activity A onRestoreInstanceState() savedInstanceState:" + savedInstanceState);
    }
    
    
    //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）
    @Override
    protected void onRestart() {
    	super.onRestart();
    	Util.log("Activity A onRestart()");
    }
    

}

 

Activity B的代码如下：

 

[java] view plaincopyprint?
  1. package com.zhuozhuo; 
  2.  
  3. import android.app.Activity; 
  4. import android.app.AlertDialog; 
  5. import android.app.Dialog; 
  6. import android.content.Intent; 
  7. import android.os.Bundle; 
  8. import android.os.Debug; 
  9. import android.util.Log; 
  10. import android.view.View; 
  11. import android.view.View.OnClickListener; 
  12.  
  13. publicclass ActivityB extends Activity { 
  14.     /** Called when the activity is first created. */ 
  15.     @Override 
  16.     publicvoid onCreate(Bundle savedInstanceState) { 
  17.         super.onCreate(savedInstanceState); 
  18.         Util.log("Activity B onCreate()"); 
  19.         setContentView(R.layout.main); 
  20.  
  21.     } 
  22.      
  23.      
  24.     @Override 
  25.     publicvoid onStart() { 
  26.         super.onStart(); 
  27.          
  28.         Util.log("Activity B onStart()"); 
  29.     } 
  30.      
  31.     //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用  
  32.     //在这里可以开始动画，打开外部设备(camera等)  
  33.     //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见  
  34.     @Override 
  35.     publicvoid onResume() { 
  36.         super.onResume(); 
  37.         Util.log("Activity B onResume()"); 
  38.     } 
  39.      
  40.     //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点  
  41.     //当activity将要被遮挡时调用  
  42.     //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）  
  43.     //这里停止那些占用cpu时间的任务，如动画，camera等  
  44.     //对比onSaveInstanceState(Bundle):  
  45.     //onSaveInstanceState(Bundle) 实现保存activity实例的状态  
  46.     //而onPause()可以保存全局的持久化数据(content providers,files等)  
  47.     @Override 
  48.     publicvoid onPause() { 
  49.         super.onPause(); 
  50.         Util.log("Activity B onPause()"); 
  51.     } 
  52.      
  53.  
  54.     //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收  
  55.     @Override 
  56.     publicvoid onStop() { 
  57.         super.onStop(); 
  58.         Util.log("Activity B onStop()"); 
  59.     } 
  60.      
  61.     //在activity销毁之前处理  
  62.     @Override 
  63.     publicvoid onDestroy() { 
  64.         super.onDestroy(); 
  65.         Util.log("Activity B onDestroy()"); 
  66.     } 
  67.      
  68.   //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据  
  69.      
  70.     @Override 
  71.     protectedvoid onSaveInstanceState (Bundle outState) { 
  72.         super.onSaveInstanceState(outState); 
  73.         outState.putString("key", "value"); 
  74.         Util.log("Activity B onSaveInstanceState() outState:" + outState); 
  75.     } 
  76.      
  77.     //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）  
  78.     @Override 
  79.     protectedvoid onRestoreInstanceState (Bundle savedInstanceState) { 
  80.         super.onRestoreInstanceState(savedInstanceState); 
  81.         Util.log("Activity B onRestoreInstanceState() savedInstanceState:" + savedInstanceState); 
  82.     } 
  83.      
  84.      
  85.     //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）  
  86.     @Override 
  87.     protectedvoid onRestart() { 
  88.         super.onRestart(); 
  89.         Util.log("Activity B onRestart()"); 
  90.     } 
  91.      
  92.      
  93.      
  94. }  
package com.zhuozhuo;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Intent;
import android.os.Bundle;
import android.os.Debug;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;

public class ActivityB extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Util.log("Activity B onCreate()");
        setContentView(R.layout.main);

    }
    
    
    @Override
    public void onStart() {
    	super.onStart();
    	
    	Util.log("Activity B onStart()");
    }
    
    //在onRestoreInstanceState(Bundle)  onRestart()  onPause() 之后调用
    //在这里可以开始动画，打开外部设备(camera等)
    //注意这个方法并无意味着activity是可见的，activity还有可能被遮挡（锁屏界面），使用onWindowFocusChanged(boolean)来确认window是否可见
    @Override
    public void onResume() {
    	super.onResume();
    	Util.log("Activity B onResume()");
    }
    
    //属于前台生命周期，此时activity在所有其他activity之上，并且获取了焦点
    //当activity将要被遮挡时调用
    //在此应该完成一些轻量级的数据处理（因为只有此方法return后，新的activity才会被创建）
    //这里停止那些占用cpu时间的任务，如动画，camera等
    //对比onSaveInstanceState(Bundle):
    //onSaveInstanceState(Bundle) 实现保存activity实例的状态
    //而onPause()可以保存全局的持久化数据(content providers,files等)
    @Override
    public void onPause() {
    	super.onPause();
    	Util.log("Activity B onPause()");
    }
    

    //这个方法不一定会被调用，当内存紧张时，在执行onPause()之后Activity会被回收
    @Override
    public void onStop() {
    	super.onStop();
    	Util.log("Activity B onStop()");
    }
    
    //在activity销毁之前处理
    @Override
    public void onDestroy() {
    	super.onDestroy();
    	Util.log("Activity B onDestroy()");
    }
    
  //当Activity被完全遮挡时，意味着此Activity有可能被kill，所以在此时保存ui数据(保存持久化的数据在onPause()中实现)，以便在用户返回应用时恢复数据
    
    @Override
    protected void onSaveInstanceState (Bundle outState) {
    	super.onSaveInstanceState(outState);
    	outState.putString("key", "value");
    	Util.log("Activity B onSaveInstanceState() outState:" + outState);
    }
    
    //在activity要被重新创建时调用（包括activity被销毁和横竖屏切换等状况）
    @Override
    protected void onRestoreInstanceState (Bundle savedInstanceState) {
    	super.onRestoreInstanceState(savedInstanceState);
    	Util.log("Activity B onRestoreInstanceState() savedInstanceState:" + savedInstanceState);
    }
    
    
    //在onStop()之后调用，这里可以重新查询获取cursor（因为cursor有可能在onStop时失效了）
    @Override
    protected void onRestart() {
    	super.onRestart();
    	Util.log("Activity B onRestart()");
    }
    
    
    
}

 

log打印信息如下：

打开Activity A:

点击按钮打开Activity B:

按back键返回Activity A:

退出Activity A（完整的流程）:

函数调用的流程图如下：

场景二解释：

这里主要说一下与场景一不同的地方。

1、当打开新的Activity B时，系统会告诉Activity A：“你要被Activity B遮挡了，你要把活动状态记录下来么？”（例如：可以把EditText已输入的Text保存下来）

当Activity A将要被遮挡时，一般情况下void onSaveInstanceState (Bundle outState)会在onResume()之前调用，目的是让Activity A把当前的活动状态保存下，因为在内存不足的情况下，被遮挡的Activity有可能会被系统杀死，通过保存Activity的活动状态，在Activity重新创建的时候会在onCreate(Bundle savedInstanceState)中传入savedInstanceState，这样Activity就可以恢复到被杀死前的状态。(在onRestoreInstanceState (Bundle savedInstanceState)实现活动状态的恢复也可)

onSaveInstanceState()会被调用的两种情况： (1)如果场景一中按Home键(而不是back键)返回到主界面，那么当前Activity需要保存活动状态，因为Activity此时并未销毁，只是被放到了后台，有可能在内存紧张的时候被系统回收。

(2)当Activity遮挡时,会调用onSaveInstanceState()

 

2、此时Activity A被暂停，调用的是onResume()方法

3、Activity B开始了它全新的生命，生命周期函数的调用顺序与场景一相同

 

4、Activity A接着调用onStop()方法

 

5、按Back键返回到Activity A时，系统会调用onRestart()函数，告诉Activity A：“回到你这里了”

在这里可以初始化在onStop中关闭了的cursor

posted on 2013-08-20 13:31  昊仔  阅读(428)  评论(0)  编辑  收藏  举报