Activity工具类

项目中有一个需求，当接收到语音的关闭应用广播时，需要关闭我们的应用。
即受到广播后遍历所有当前打开的Activity，将它们都杀掉。
解决思路就是每个Activity的oncreate方法中将该Activity加入一个栈，onDestroy方法中将该Activity移出栈，当最后受到关闭应用广播时遍历栈，将栈中的每一个Activity杀掉。
对于上面的操作，整理了一个Activity相关的工具类，以后可以直接COPY使用：

import android.app.Activity;

import java.util.LinkedList;
import java.util.Stack;

/**
 * @date 2021/7/1
 * Activity工具类，用于实现Activity相关的操作
 */
public class ActivityUtils {
    protected Stack<Activity> activityStack;
    public static ActivityUtils getInstance(){
        return ActivityUtilHolder.mInstance;
    }

    private static class ActivityUtilHolder {
        private static final ActivityUtils mInstance = new ActivityUtils();
    }

    private ActivityUtils() {
        if (null == activityStack) {
            activityStack = new Stack();
        }
    }

    /**
     * 添加Activity到堆栈
     */
    public void add(Activity activity){
        if (null !=activity) {
            activityStack.add(activity);
        }
    }

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

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

    /**
     * 得到指定类名的Activity
     */
    public Activity getActivity(Class<?> cls) {
        if (null == activityStack){
            return null;
        }
        for (Activity activity : activityStack) {
            if (activity.getClass().equals(cls)) {
                return activity;
            }
        }
        return null;
    }


    /**
     * 结束指定类名的Activity
     */
    public void finishActivity(Class<?> cls) {
        if (null == activityStack ||activityStack.size() == 0){
            return;
        }
        for (int i = activityStack.size()-1; i >=0 ; i--) {
            if (activityStack.get(i).getClass().equals(cls)) {
                remove(activityStack.get(i));
            }
        }
    }
    /**
     * 结束最近的Activity
     */
    public void finishCurrentActivity() {
        if (null == activityStack ||activityStack.size() == 0){
            return;
        }
        Activity activity = activityStack.lastElement();
        remove(activity);
    }
    /**
     * 清除activity，只保留某个Acitivity
     */
    public void finishExceptActivity(Class<?> cls) {
        if (null == activityStack ||activityStack.size() == 0){
            return;
        }
        for (int i = activityStack.size()-1; i >=0 ; i--) {
            Class<? extends Activity> aClass = activityStack.get(i).getClass();
            if (!aClass.equals(cls)) {
                remove(activityStack.get(i));
            }
        }
    }

    public void killActivity(Activity activity) {
        activity.finish();
        activityStack.remove(activity);
        activity=null;
    }
    public  <T extends Activity> T getTop()
    {
        return (T) activityStack.lastElement();
    }
    public int getCount(){
        return activityStack ==null?0: activityStack.size();
    };
    public boolean isEmpty()
    {
        return getCount()==0;
    }
    public boolean exist(Class<? extends Activity> clazz){
        for (Activity activity: activityStack) {
            if(activity.getClass().getName().equals(clazz.getName()))
            {
                return true;
            }
        }
        return false;
    }

    //遍历栈中所有Activity，杀掉所有Activity
    public void clearAllActivity() {
        int n= activityStack.size();
        for (int i=0;i<n;i++){
            killActivity(activityStack.firstElement());
        }
    }

//    public void exitApp(Context context) {
//        //先清除Activity
//        clearAllActivity();
//        ActivityManager activityManager  = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
//        //再killProcesses
//        activityManager.killBackgroundProcesses(context.getPackageName());
//        System.exit(0);
//    }

    public void rollBack(Class<? extends Activity> clazz){
        if(!exist(clazz)){
            return;
        }
        LinkedList<Activity> activities = new LinkedList<>();
        activities.addAll(activityStack);
        boolean isfind = false;
        for(Activity activity : activities){
            if(activity.getClass().getName().equals(clazz.getName())){
                isfind = true;
                continue;
            }
            if(isfind) {
                killActivity(activity);
            }
        }
    }
}