如何安全退出已调用多个Activity的Application？（专业版）

怼烎@ 2022-08-08 12:54 105阅读 0赞

转载出处：http://www.cnblogs.com/olvo/archive/2012/05/11/2496699.html

对于单一Activity的应用来说，退出很简单，直接finish()即可。   
当然，也可以用killProcess()和System.exit()这样的方法。   
  
但是，对于多Activity的应用来说，在打开多个Activity后，如果想在最后打开的Activity直接退出，上边的方法都是没有用的，因为上边的方法都是结束一个Activity而已。   
当然，网上也有人说可以。   
就好像有人问，在应用里如何捕获Home键，有人就会说用keyCode比较KEYCODE\_HOME即可，而事实上如果不修改framework，根本不可能做到这一点一样。   
所以，最好还是自己亲自试一下。   
  
那么，有没有办法直接退出整个应用呢？   
在2.1之前，可以使用ActivityManager的restartPackage方法。   
它可以直接结束整个应用。在使用时需要权限android.permission.RESTART\_PACKAGES。   
注意不要被它的名字迷惑。   
  
可是，在2.2，这个方法失效了。   
在2.2添加了一个新的方法，killBackgroundProcesses()，需要权限 android.permission.KILL\_BACKGROUND\_PROCESSES。   
可惜的是，它和2.2的restartPackage一样，根本起不到应有的效果。   
  
另外还有一个方法，就是系统自带的应用程序管理里，强制结束程序的方法，forceStopPackage()。   
它需要权限android.permission.FORCE\_STOP\_PACKAGES。   
并且需要添加android:sharedUserId="android.uid.system"属性   
同样可惜的是，该方法是非公开的，他只能运行在系统进程，第三方程序无法调用。   
因为需要在Android.mk中添加LOCAL\_CERTIFICATE := platform。   
而Android.mk是用于在Android源码下编译程序用的。   
  
从以上可以看出，在2.2，没有办法直接结束一个应用，而只能用自己的办法间接办到。   
  
现提供几个方法，供参考：   
  
1、抛异常强制退出：   
该方法通过抛异常，使程序Force Close。   
验证可以，但是，需要解决的问题是，如何使程序结束掉，而不弹出Force Close的窗口。   
  
2、记录打开的Activity：   
每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。   
  
3、发送特定广播：   
在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。   
  
4、递归退出   
在打开新的Activity时使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭。   
  
除了第一个，都是想办法把每一个Activity都结束掉，间接达到目的。   
但是这样做同样不完美。   
你会发现，如果自己的应用程序对每一个Activity都设置了nosensor，在两个Activity结束的间隙，sensor可能有效了。   
但至少，我们的目的达到了，而且没有影响用户使用。   
  
为了编程方便，最好定义一个Activity基类，处理这些共通问题。

下面是转载的一片文章   
Android之完美退出方法（2.1-2.2-2.3SDK版本测试通过）\[转\]   
因为网上有很多种退出方法，可是实际上很多方法都不通用（在某个版本下可用，到了另一个版本就不行），或者方法的实际效果根本就和其描述不符（也不知道那些发帖的人测没测试过）。   
  
但我们的需求又确实存在。在某些情况下，我们需要在应用中打开多个Activity，但如果仅仅使用finish()方法就不能在需要的时候达到一次性退 出的效果，自己作为一个Android退出问题的受害者，通过良久思考和实际测试，找到了一个比较不错的，在2.1-2.2-2.3版本下都通用的完全退 出方法（2.1版本也基本可以代表1.5~2.1版本）！   
  
PS：测试全部在模拟器环境下进行   
  
我首先进行一下说明，下面两种方法效果完全相同   
1，android.os.Process.killProcess(android.os.Process.myPid()) ; （这是Dalvik VM的本地方法）   
2，System.exit(0); （常规java、c\#的标准退出法，返回值为0代表正常退出 ）   
之后我的说明全部以android.os.Process.killProcess(android.os.Process.myPid()) 方法为准。   
  
另外，我后边所说的程序入口即为在AndroidManifest.xml中配置为如下语句的Activity   
<action android:name="android.intent.action.MAIN" />   
<category android:name="android.intent.category.LAUNCHER" />   
  
下面开始我们的Android完美退出之旅：   
先从网上的一段说明说起：   
A->B   
B中执行android.os.Process.killProcess(android.os.Process.myPid());   
结果是结束了B，然后重新启动A。   
实际情况是这样：A为程序入口，B中调用killProcess(android.os.Process.myPid())操作，实际上是将程序入口A和执行该语句的Activity B都关闭，并重新启动新的程序入口A。   
所以，如果过程是A->B->C   
则实际情况是：A为程序入口，C中调用killProcess(android.os.Process.myPid())操作将程序入口A和执行该语句的Activity C都关闭，并重新启动新的程序入口A（在Activity窗口历史栈当中，旧A 被关闭，新A 仍然会被放置在 旧A 所在的栈位置，不会到达栈顶端）。   
  
PS: 如果killProcess(android.os.Process.myPid())或System.exit(0)是在程序入口A处执行，则是将入口A关闭，不会再开启新的A.   
  
有人要问了，B Activity呢？ B还存在着，B Activity没有被关闭。   
如何解决这个问题？   
首先说明一点   
android.os.Process.killProcess(android.os.Process.myPid()) ;语句执行之后，后边的代码都将不再执行；   
而finish();或startActivity(A.this,B.class);语句在执行完成后仍旧会执行后续的代码。（使用Thread.sleep多次验证，不用担心finish()过后不能startActivity了，相反也一样）。   
所以，我们就可以充分利用这一点，既然finish();和startActivity(A.this,B.class);语句在执行后仍然可以执行后续代码操作，那我们可以将之组合在一个代码片段中，即   
startActivity(new Intent(B.this, C.class));   
finish();   
或   
finish();   
startActivity(new Intent(B.this, C.class));   
都是可以的，我们在B中使用该代码段，既将B Activity关闭了，也打开了C Activity，之前的问题Done！   
如果你还有D，E，F ... 那也一样，在每次跳转到下一个Activity时，将finish()一块用上。使用这种方式，多余的Activity就能够被关闭了。   
  
PS：很囧的是，在我自己的Android应用中，在程序入口处调用这种组合代码，会直接将新开启的Activity也一并关闭，但在我创建的简单工程当中却不会有这种情况，不知道为什么，还在寻找原因中......（也请高手指点一二）   
  
  
最后 假设我们有下面一种需求，对上边的内容进行总结：   
Activity的开启过程为 1.Index --> 2.A\_Activity --> 3.B\_Activity --> 4.Index，在4.Index中实现退出，Index为程序入口。   
  
Index   
退出：就是最简单的finish();   
跳转：也是最简单的 startActivity(new Intent(Index.this, A\_Activity.class));   
  
A\_Activity   
退回到首界面：分两种情况   
1，需要Index更新（我的Index就有这个需求，首页面色彩发生变化）   
使用android.os.Process.killProcess(android.os.Process.myPid()) ;关闭自己和之前的Index，创建新的Index；   
2，不需要新的Index，Index无变化   
使用最简单的finish()，并且效率还要高些。   
跳转：   
finish();   
startActivity(new Intent(A\_Activity.this, C.class));   
关闭自身，开启除 Index 之外的其它Activity。   
  
B\_Activity   
操作与 A\_Activity 相同。当然跳转语句变成了   
finish();   
startActivity(new Intent(B\_Activity.this, Index.class));   
  
  
  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
上边的内容就是这样了，下面我再告诉你另外一种方法，可以实现不关闭中途的Activity，而是在后边的操作中一次性关闭前边开启的所有Activity，可以满足一些人通过按返回键返回上一个界面的要求！   
通过Android的窗口类提供的历史栈，巧妙利用stack的原理，我们在Intent中加入标志 Intent.FLAG\_ACTIVITY\_CLEAR\_TOP。   
  
Intent intent = new Intent();   
intent.setClass(One.this, Two.class);   
intent.setFlags(Intent.FLAG\_ACTIVITY\_CLEAR\_TOP);   
startActivity(intent);   
  
假定有如下需求：   
1.Index --> 2.A\_Activity --> 3.B\_Activity   
  
在3中设置 intent.setClass(B\_Activity.this, Index.class);   
跳转后，程序会从栈顶逐个向后查找，直到找 到栈中最近的Index，然后将这一路找到的Activity全部关闭，包括1、2、3（也就不需要像我先前的方法一路finish了，也保留了途中经过 的Activity），最后再自动建一个新的Index Activity放到栈顶的位置，接下来在Index窗口中使用finish方法即可退出。   
  
如果没有理解，看这个例子：   
如果3中设置的是 intent.setClass(B\_Activity.this, A\_Activity.class);   
则是将2，3关闭，再新建一个4.A\_Activity，栈中就变成了   
1.Index --> 4.A\_Activity，懂了吧！   
值得注意的是，在下面的情况中   
1.Index --> 2.A\_Activity --> 3.B\_Activity --> 4.Index --> 5.A\_Activity   
在5中使用intent.setClass(A\_Activity.this, B\_Activity.class);   
结果不是   
1.Index --> 2.A\_Activity --> 6.B\_Activity   
而是   
1.Index --> 2.A\_Activity --> 3.B\_Activity --> 4.Index--> 5.A\_Activity --> 6.B\_Activity，因为4（程序入口）的存在，所以5对栈的操作不会到达3，而是发现4、5中都没有B\_Activity后，没有关闭任何 Activity，只在栈顶端新建了一个6.B\_Activity。   
这也间接说明了Dalvik虚拟机的遍历算 法只进行到最近的程序入口，就认为后边没有该程序的Activity了。所以良好的Android编程习惯是，新建一个程序入口时，一定把老程序入口关 掉，这也解释了为什么用killProcess方法更新后的程序入口Index一定还是在栈中的老位置，而不是到栈顶端。   
  
以上都是我通过新建的一个简单工程测试验证过的。   
不过很囧的是，这种退出方法，我在自己的应用程序下测试，结果都是直接退出到home界面，连Index界面都没有出现，还想请高手赐教一下这里边深层次的原因。   
  
  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*   
还有一种比较流行的Android经典完美退出方法，使用单例模式创建一个Activity管理对象，该对象中有一个Activity容器（具体实现自己处理，使用LinkedList等）专门负责存储新开启的每一个Activity，并且容易理解、易于操作，非常不错！   
MyApplication类（储存每一个Activity，并实现关闭所有Activity的操作）   
public class MyApplication extends Application \{   
  
private List<Activity> activityList = new LinkedList<Activity>();   
private static MyApplication instance;   
  
private MyApplication()   
\{   
\}   
//单例模式中获取唯一的MyApplication实例   
public static MyApplication getInstance()   
\{   
if(null == instance)   
\{   
instance = new MyApplication();   
\}   
return instance;   
\}   
//添加Activity到容器中   
public void addActivity(Activity activity)   
\{   
activityList.add(activity);   
\}   
//遍历所有Activity并finish   
public void exit()   
\{   
for(Activity activity:activityList)   
\{   
activity.finish();   
\}   
System.exit(0);   
\}   
\}   
在每一个Activity中的onCreate方法里添加该Activity到MyApplication对象实例容器中   
MyApplication.getInstance().addActivity(this);   
在需要结束所有Activity的时候调用exit方法   
MyApplication.getInstance().exit();   
  
个人非常喜欢这种方法！（非常感谢flyrabbits的帮助）   
  
  
—————————————分割线—————————————————   
我对其他一些退出方法进行的一点介绍和点评（不到之处还请指正）：   
@restartPackage(getPackageName())(具体就不介绍了)   
我在SDK2.1版本下开发的一款小软件，放到Android2.2或2.3操作系统上无法退出，因为restartPackage方法在SDK2.1以 后版本已经被废弃不用了，理由是因为它不安全，可能关闭同其他应用程序共享的Service，而这个Service别人还要用呢，你给别人关了就不对了。   
  
@有人说的终极退出方法：   
Intent startMain = new Intent(Intent.ACTION\_MAIN);   
startMain.addCategory(Intent.CATEGORY\_HOME);   
startMain.setFlags(Intent.FLAG\_ACTIVITY\_NEW\_TASK);   
startActivity(startMain);   
System.exit(0);   
实际上这种方法只是返回了Home页面，如果你再次进入应用，你会发现进入的首界面是你先前没有关闭的Activity。   
  
@调用系统隐藏forceStopPackage方法，这里是通过映射调用（也有其他方法）   
Method method = null;   
ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY\_SERVICE);   
try \{   
method = Class.forName("android.app.ActivityManager").getMethod("forceStopPackage", String.class);   
method.invoke(manager,getPackageName());   
\} catch (Exception e) \{   
Log.d("force",e.getMessage());   
\}   
我在SDK2.2和2.3的测试结果是，出现NULLPointerException，弹出错误窗口，程序被迫关闭，和预想的正常退出有差别。不过我们 可以通过修改基类实现自己的Thread.UncaughtExceptionHandler接口的uncaughtException方法，这样就不会 有错误窗口弹出。程序完全退出。   
  
@和上面一样，不过这是故意制造异常退出（上边是无意制造的异常），但我认为这毕竟是下策。

\---------------------------------------------------------------------------------------------------

以上是网上的一些作法, 其实也可以通过intent的flag实现 , intent.setFlag(FLAG\_ACTIVITY\_CLEAR\_TOP)激活一个新的acitvity,然后在新的activ ity的onCreate()方法里面finish掉.