Android基础之结束所有Activity通用方法

出处：http://blog.csdn.net/chenliguan/article/details/47295163

一、问题描述

做Android项目，退出程序时，有时不能退出所有的activity，这时我们就需要在退出时，关闭所有的activity。

二、解决方法

1.Dalvik VM的本地方法

　　android.os.Process.killProcess(android.os.Process.myPid()); 
　　获取PID，目前获取自己的也只有该API，否则从/proc中自己的枚举其他进程吧，不过要说明的是，结束其他进程不一定有权限，不然就乱套了。 
　　System.exit(0); 
　　常规java、c#的标准退出法，返回值为0代表正常退出

2.任务管理器方法

　　在Android 1.5以上才可以，同时需要权限： 
　　android:name=\”android.permission.RESTART_PACKAGES\”>

    ActivityManager am = (ActivityManager)getSystemService (Context.ACTIVITY_SERVICE); 
    am.restartPackage(getPackageName()); 
 
 
1
2

系统会将，该包下的 ，所有进程，服务，全部杀掉，就可以杀干净。

3.根据Activity的声明周期

　　我们知道Android的窗口类提供了历史栈，我们可以通过stack的原理来巧妙的实现，这里我们在A窗口打开B窗口时在Intent中直接加入标志Intent.FLAG_ACTIVITY_CLEAR_TOP，这样开启B时将会清除该进程空间的所有Activity。

　　在A窗口中使用下面的代码调用B窗口

   Intent intent = new Intent(); 
　 intent.setClass(Android123.this, CWJ.class);
　 intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  //注意本行的FLAG设置
　 startActivity(intent);
 
 
1
2
3
4

　　接下来在B窗口中需要退出时直接使用finish方法即可全部退出。

4.自定义一个Activity 栈（通用方法）。利用一个单例模式的Activity栈来存放并管理所有Activity。并提供退出所有Activity的方法。

三、自定义一个Activity 栈方法（通用方法）详解，代码如下：

package com.example.guan.activitywork;

import android.app.Activity;

import java.util.LinkedList;
import java.util.List;

/**
 * 用于处理退出程序时可以退出所有的activity，而编写的通用类
 * @author guan
 * @date 2015-8-5
 */
public class ActivityManager {

    private List<Activity> activityList = new LinkedList<Activity>();
    private static ActivityManager instance;

    private ActivityManager() {
    }

    // 单例模式中获取唯一的MyApplication实例
    public static ActivityManager getInstance() {
        if (null == instance) {
            instance = new ActivityManager();
        }
        return instance;
    }

    // 添加Activity到容器中
    public void addActivity(Activity activity) {
        activityList.add(activity);
    }

    // 移除一个activity
    public void deleteActivity(Activity activity) {
        if (activityList != null && activityList.size() > 0) {
            if (activity != null) {
                activity.finish();
                activityList.remove(activity);
                activity = null;
            }

        }
    }

    // 遍历所有Activity并finish
    public void exit() {
        for (Activity activity : activityList) {
            activity.finish();
        }
        System.exit(0);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

或者更加全面的堆栈管理类

/**
 * activity堆栈管理
 * 
 * @author blue
 */
public class ActivityStack
{
    private static ActivityStack mSingleInstance;
    private Stack<Activity> mActicityStack;

    private ActivityStack()
    {
        mActicityStack = new Stack<Activity>();
    }

    public static ActivityStack getInstance()
    {
        if (null == mSingleInstance)
        {
            mSingleInstance = new ActivityStack();
        }
        return mSingleInstance;
    }

    public Stack<Activity> getStack()
    {
        return mActicityStack;
    }

    /**
     * 入栈
     * 
     * @author blue
     */
    public void addActivity(Activity activity)
    {
        mActicityStack.push(activity);
    }

    /**
     * 出栈
     * 
     * @author blue
     */
    public void removeActivity(Activity activity)
    {
        mActicityStack.remove(activity);
    }

    /**
     * 彻底退出
     * 
     * @author blue
     */
    public void finishAllActivity()
    {
        Activity activity;
        while (!mActicityStack.empty())
        {
            activity = mActicityStack.pop();
            if (activity != null)
                activity.finish();
        }
    }

    /**
     * finish指定的activity
     * 
     * @author blue
     */
    public boolean finishActivity(Class<? extends Activity> actCls)
    {
        Activity act = findActivityByClass(actCls);
        if (null != act && !act.isFinishing())
        {
            act.finish();
            return true;
        }
        return false;
    }

    public Activity findActivityByClass(Class<? extends Activity> actCls)
    {
        Activity aActivity = null;
        Iterator<Activity> itr = mActicityStack.iterator();
        while (itr.hasNext())
        {
            aActivity = itr.next();
            if (null != aActivity && aActivity.getClass().getName().equals(actCls.getName()) && !aActivity.isFinishing())
            {
                break;
            }
            aActivity = null;
        }
        return aActivity;
    }

    /**
     * finish指定的activity之上的所有activity
     * 
     * @author blue
     */
    public boolean finishToActivity(Class<? extends Activity> actCls, boolean isIncludeSelf)
    {
        List<Activity> buf = new ArrayList<Activity>();
        int size = mActicityStack.size();
        Activity activity = null;
        for (int i = size - 1; i >= 0; i--)
        {
            activity = mActicityStack.get(i);
            if (activity.getClass().isAssignableFrom(actCls))
            {
                for (Activity a : buf)
                {
                    a.finish();
                }
                return true;
            } else if (i == size - 1 && isIncludeSelf)
            {
                buf.add(activity);
            } else if (i != size - 1)
            {
                buf.add(activity);
            }
        }
        return false;
    }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

四、使用方法

1.在onCreate()方法里面加上：

ActivityManager.getInstance().addActivity(this);
 
 
1

2.在onDestroy()方法里面加上：

ActivityManager.getInstance().deleteActivity(this);

 
 
1
2

3.退出时调用：

ActivityManager.getInstance().exit();