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

一、问题描述

做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()); 

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

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);

　　接下来在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);
    }
}

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

/** * 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.在onCreate()方法里面加上：

ActivityManager.getInstance().addActivity(this);

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

ActivityManager.getInstance().deleteActivity(this);

3.退出时调用：

ActivityManager.getInstance().exit();