Android Activity全局管理类

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

相信大家在处理Activity跳转，或者是删除指定的Activity和所有的Activity都会遇到困惑。尤其是在做项目的退出整个应用功能模块的时候，需要关闭所有的Activity，这里对于新手来说经常性会存在MainActivity已经finish掉了，但是还有其他的Activity存在。那么这个时候我们就需要这么个管理类了。

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

1.自定义一个Activity 栈方法（通用方法）

package com.project.test;

import android.app.Activity;

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

/**
 * Author:AND
 * Time:2018/3/16.
 * Email:2911743255@qq.com
 * Description:用于处理退出程序时可以退出所有的activity，而编写的通用类
 * Detail:
 */

public class ActivityManager {

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

    private ActivityManager() {
    }

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

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

    /**
     * 移除一个activity
     *
     * @param 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);
    }
}

大家都知道，Android系统有自己的Activity管理机制，也就ActivityStack(栈)。奉行着先进后出，后进先出的原则。那么我们就通过Stack来进行Activity的管理。

2.更加全面的堆栈管理类

 /**
 * Author:AND
 * Time:2018/3/16.
 * Email:2911743255@qq.com
 * Description: activity堆栈管理
 * Detail:
 */

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

3.使用方法

1. 在onCreate()方法里面加上：
   ActivityManager.getInstance().addActivity(this);
2. 在onDestroy()方法里面加上:
   ActivityManager.getInstance().deleteActivity(this);
3. 退出时调用:
   ActivityManager.getInstance().exit();

另一个更加全面的全栈管理,我个人非常喜欢这个:

import android.app.Activity;
import android.app.ActivityManager;
import android.content.Context;

import java.util.Stack;

/**
 * Author:AND
 * Time: 2018/3/31.
 * Email:2911743255@qq.com
 * Description:全栈管理
 * Detail
 */
public class ActivityStackManager {
    private static Stack<Activity> activityStack;

    private static ActivityStackManager instance;

    private ActivityStackManager() {
    }

    /**
     * 单一实例
     */
    public static ActivityStackManager getAppManager() {
        if (instance == null) {
            instance = new ActivityStackManager();
        }
        return instance;
    }

    /**
     * 添加Activity到堆栈
     */
    public void addActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new Stack<Activity>();
        }
        activityStack.add(activity);
    }

    /**
     * 获取当前Activity（堆栈中最后一个压入的）
     */
    public Activity currentActivity() {
        Activity activity = activityStack.lastElement();
        return activity;
    }

    /**
     * 结束当前Activity（堆栈中最后一个压入的）
     */
    public void finishActivity() {
        Activity activity = activityStack.lastElement();
        finishActivity(activity);
    }

    /**
     * 结束指定的Activity
     */
    public void finishActivity(Activity activity) {
        if (activity != null) {
            activityStack.remove(activity);
            activity.finish();
            activity = null;
        }
    }

    /**
     * 结束指定类名的Activity
     */
    public void finishActivity(Class<?> cls) {
        for (Activity activity : activityStack) {
            if (activity.getClass().equals(cls)) {
                finishActivity(activity);
            }
        }
    }

    /**
     * 结束所有Activity
     */
    public void finishAllActivity() {
        for (int i = 0, size = activityStack.size(); i < size; i++) {
            if (null != activityStack.get(i)) {
                activityStack.get(i).finish();
            }
        }
        activityStack.clear();
    }

    /**
     * 退出应用程序
     */
    @SuppressWarnings("deprecation")
    public void AppExit(Context context) {
        try {
            finishAllActivity();
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            activityManager.restartPackage(context.getPackageName());
            System.exit(0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}