activity-双击退出

对于一个应用程序可能有很多个Activity,可能每个人并不想一个个的去关闭Activity，也有可能忘了，那怎么关闭所有的未关闭的Activity呢，其实有很多方法，但是我最喜欢的一种就是通过广播事件去关闭，这样简单易懂，方便操作，很快捷。

首先就是建立一个父类，让所有的activity继承父类，这样就不用每次都去注册广播，只要在父类注册好就行了，代码如下：

[java]  view plain copy

1. package net.loonggg.test;  
2.   
3. import android.app.Activity;  
4. import android.content.BroadcastReceiver;  
5. import android.content.Context;  
6. import android.content.Intent;  
7. import android.content.IntentFilter;  
8.   
9. public class BaseActivity extends Activity {  
10.     /** 
11.      * 关闭Activity的广播，放在自定义的基类中，让其他的Activity继承这个Activity就行 
12.      */  
13.     protected BroadcastReceiver finishAppReceiver = new BroadcastReceiver() {  
14.         @Override  
15.         public void onReceive(Context context, Intent intent) {  
16.             finish();  
17.         }  
18.     };  
19.   
20.     @Override  
21.     public void onResume() {  
22.         super.onResume();  
23.         // 在当前的activity中注册广播  
24.         IntentFilter filter = new IntentFilter();  
25.         filter.addAction("net.loonggg.exitapp");  
26.         this.registerReceiver(this.finishAppReceiver, filter);  
27.     }  
28.   
29.     @Override  
30.     protected void onDestroy() {  
31.         super.onDestroy();  
32.         this.unregisterReceiver(this.finishAppReceiver);  
33.     }  
34. }  

其次就是子类继承，代码如下：

[java]  view plain copy

1. package net.loonggg.test;  
2.   
3. import android.content.Intent;  
4. import android.os.Bundle;  
5. import android.view.KeyEvent;  
6. import android.view.View;  
7. import android.widget.Button;  
8. import android.widget.Toast;  
9.   
10. public class MainActivity extends BaseActivity {  
11.     private Button btn;  
12.   
13.     @Override  
14.     protected void onCreate(Bundle savedInstanceState) {  
15.         super.onCreate(savedInstanceState);  
16.         setContentView(R.layout.activity_main);  
17.         btn = (Button) findViewById(R.id.btn);  
18.   
19.         btn.setOnClickListener(new View.OnClickListener() {  
20.   
21.             @Override  
22.             public void onClick(View v) {  
23.                 Intent intent = new Intent(getApplicationContext(),  
24.                         SecondActivity.class);  
25.                 startActivity(intent);  
26.             }  
27.         });  
28.     }  
29.   
30.     private long exitTime = 0;  
31.   
32.     @Override  
33.     public boolean onKeyDown(int keyCode, KeyEvent event) {  
34.         if (KeyEvent.KEYCODE_BACK == keyCode) {  
35.             // 判断是否在两秒之内连续点击返回键，是则退出，否则不退出  
36.             if (System.currentTimeMillis() - exitTime > 2000) {  
37.                 Toast.makeText(getApplicationContext(), "再按一次退出程序",  
38.                         Toast.LENGTH_SHORT).show();  
39.                 // 将系统当前的时间赋值给exitTime  
40.                 exitTime = System.currentTimeMillis();  
41.             } else {  
42.                 exitApp();  
43.             }  
44.             return true;  
45.         }  
46.         return super.onKeyDown(keyCode, event);  
47.     }  
48.   
49.     /** 
50.      * 退出应用程序的方法，发送退出程序的广播 
51.      */  
52.     private void exitApp() {  
53.         Intent intent = new Intent();  
54.         intent.setAction("net.loonggg.exitapp");  
55.         this.sendBroadcast(intent);  
56.     }  
57.   
58.     @Override  
59.     protected void onDestroy() {  
60.         super.onDestroy();  
61.         System.out.println("-------MainActivity-------->onDestroy()");  
62.     }  
63.   
64. }  

其实不用多说，我相信大家代码肯定都看懂了，主要是思路，代码都是非常简单的基础的。那下边我再介绍连续点击两次返回键退出应用程序的方法，方法如下：

[java]  view plain copy

1. /** 
2.      * 记录标记时间 
3.      */  
4.     private long exitTime = 0;  
5.   
6.     @Override  
7.     public boolean onKeyDown(int keyCode, KeyEvent event) {  
8.         if (KeyEvent.KEYCODE_BACK == keyCode) {  
9.             // 判断是否在两秒之内连续点击返回键，是则退出，否则不退出  
10.             if (System.currentTimeMillis() - exitTime > 2000) {  
11.                 Toast.makeText(getApplicationContext(), "再按一次退出程序",  
12.                         Toast.LENGTH_SHORT).show();  
13.                 // 将系统当前的时间赋值给exitTime  
14.                 exitTime = System.currentTimeMillis();  
15.             } else {  
16.                 exitApp();  
17.             }  
18.             return true;  
19.         }  
20.         return super.onKeyDown(keyCode, event);  
21.     }  

到这里就完了！非常简单吧！

现在许多应用都有一个“再按一次退出”的效果，其实实现这个不难，具体可以看我的另外一篇文章：http://maosidiaoxian.iteye.com/blog/1403040 

不过最近又对以前写的东西再次封装，原因是以前是写死了，一定是“再次一次退出”的效果，而没有“再按一次XXX”的。而出现这个需求是因为最近在写的一个小的游戏应用，有“新游戏”的按钮，我觉得在响应这个事件时先弹出一个对话框来确认是否开始新游戏没什么必要，因为频率比较高，久了用户会很烦。朋友说可以做成“再按一次开始新游戏”。 

于是封装了“再次一次XXX”的代码。具体如下： 

Java代码  

1. /* 
2.  * @(#)DoubleClick.java            Project:com.sinaapp.msdxblog.androidkit 
3.  * Date:2012-3-20 
4.  * 
5.  * Copyright (c) 2011 CFuture09, Institute of Software,  
6.  * Guangdong Ocean University, Zhanjiang, GuangDong, China. 
7.  * All rights reserved. 
8.  */  
9. package com.sinaapp.msdxblog.androidkit.ui.util;  
10.   
11. import android.content.Context;  
12. import android.os.Handler;  
13. import android.os.HandlerThread;  
14. import android.widget.Toast;  
15.   
16. /** 
17.  * @author Geek_Soledad (66704238@51uc.com) 
18.  */  
19. public abstract class DoubleClick {  
20.     protected Context mContext;  
21.     private boolean willDo;  
22.     private Runnable task = new Runnable() {  
23.         @Override  
24.         public void run() {  
25.             willDo = false;  
26.         }  
27.     };  
28.   
29.     public DoubleClick(Context context) {  
30.         mContext = context;  
31.     }  
32.   
33.     /** 
34.      * 当某个动作要双击才执行时，调用此方法。 
35.      *  
36.      * @param delayTime 
37.      *            判断双击的时间。 
38.      * @param msg 
39.      *            当第一次点击时，弹出的提示信息。如果为null，则不作提示。 
40.      */  
41.     public void doDoubleClick(int delayTime, String msg) {  
42.         if (willDo) {  
43.             doOnDoubleClick();  
44.         } else {  
45.             keepInDelayTime(delayTime);  
46.             showMsgInToast(delayTime, msg);  
47.         }  
48.     }  
49.   
50.     /** 
51.      * 在双击之后执行的事情。 
52.      */  
53.     abstract protected void doOnDoubleClick();  
54.   
55.     /** 
56.      * 判断是否双击。 
57.      *  
58.      * @param delayTime 
59.      *            是否双击的判断时间。 
60.      */  
61.     final private void keepInDelayTime(int delayTime) {  
62.         willDo = true;  
63.         HandlerThread thread = new HandlerThread("doTask");  
64.         thread.start();  
65.         new Handler(thread.getLooper()).postDelayed(task, delayTime);  
66.   
67.     }  
68.   
69.     /** 
70.      * 显示提示信息。 
71.      *  
72.      * @param msg 
73.      *            要显示的信息。 
74.      */  
75.     private void showMsgInToast(int delayTime, String msg) {  
76.         if (msg != null) {  
77.             Toast.makeText(mContext, msg, delayTime).show();  
78.         }  
79.     }  
80. }  

然后关于再按一次退出，仅需要继承以上类并实现其抽象方法即可。 

Java代码  

1. /** 
2.  * 在双击之后执行的事情。 
3.  */  
4. abstract protected void doOnDoubleClick();  

以下是“再次一次退出”的再次封装。不过这里我用的是单例模式，一个是我觉得对于一个应用，退出也就完了，所以它对应的这个“再次一次退出”的辅助类也是只有一个的，另一个是单例模式的话，我不需要为它写个成员变量，再在一开始的时候对它初始化，对我原来的代码影响很小。代码如下： 

Java代码  

1. /* 
2.  * @(#)ExitDoubleClick.java            Project:com.sinaapp.msdxblog.androidkit 
3.  * Date:2012-3-20 
4.  * 
5.  * Copyright (c) 2011 CFuture09, Institute of Software,  
6.  * Guangdong Ocean University, Zhanjiang, GuangDong, China. 
7.  * All rights reserved. 
8.  */  
9. package com.sinaapp.msdxblog.androidkit.ui.util;  
10.   
11.   
12. import android.app.Activity;  
13. import android.content.Context;  
14.   
15.   
16. /** 
17.  * 双击退出Activity的类。 
18.  *  
19.  * @author Geek_Soledad (66704238@51uc.com) 
20.  */  
21. public class ExitDoubleClick extends DoubleClick {  
22.   
23.     private static ExitDoubleClick exitDoubleClick;  
24.   
25.     private ExitDoubleClick(Context context) {  
26.         super(context);  
27.     }  
28.   
29.     /** 
30.      * 返回一个双击退出的实例。 
31.      *  
32.      * @param context 
33.      * @return ExitDoubleClick 
34.      */  
35.     public static synchronized ExitDoubleClick getInstance(Context context) {  
36.         if (exitDoubleClick == null) {  
37.             exitDoubleClick = new ExitDoubleClick(context);  
38.         }  
39.         return exitDoubleClick;  
40.     }  
41.   
42.     /** 
43.      * 双击之后退出。 
44.      */  
45.     @Override  
46.     protected void doOnDoubleClick() {  
47.         ((Activity) mContext).finish();  
48.         exitDoubleClick = null;  
49.     }  
50.       
51.     /* (non-Javadoc) 
52.      * @see com.sinaapp.msdxblog.androidkit.util.DoubleClick#doDoubleClick(int, java.lang.String) 
53.      */  
54.     @Override  
55.     public void doDoubleClick(int delayTime, String msg) {  
56.         if (msg == null || msg.equals("")) {  
57.             msg = "再按一次退出";  
58.         }  
59.         super.doDoubleClick(delayTime, msg);  
60.     }  
61.   
62. }  

注意，在退出之后需要对exitDoubleClick赋值为null（或者可以调用System.exit(0)方法？），否则在下次启动时可能无法正常退出，因为这时调用的mContext已经不是当前的Activity实例了，所以无法对当前的Activity实例用finish()退出。