美文网首页1-Android开发知识功能专区Android开发
Android 项目开发必备-Activity管理栈之Activ

Android 项目开发必备-Activity管理栈之Activ

作者: PaperKite | 来源:发表于2017-12-13 16:23 被阅读537次
    timg.jpg

    在我们日常开发当中你一定为无缘无故的内存泄漏而烦恼,或者因为多个Activity互相跳转而烦恼,这时候我们就需要一个利器-ActManager.有了这个帮助类我们就可以省去静态去写一些activity启动模式了。

    设置Actmanager为静态变量:

    因为我们全局只需要一个Actmaanager,所有我们把它设置为静态变量,放在静态区域.

    private static ActManager instance = new ActManager();
    
        public static ActManager Instance() {
            return instance;
        }
    

    设置保护重复跳转

    
        /**
         * 防止页面短时间重复跳转
         *
         * @return true:可以跳转 false:不跳转
         */
        private boolean checkForward(Context context) {
            Activity activity = null;
            boolean flag = true;
            try {
                activity = (Activity) context;
            } catch (Exception e) {
                Logger.output("Warning!!! ApplicationContext");
                //说明是ApplicationContext
            }
    
            long time = Calendar.getInstance().getTimeInMillis();
            if (null != activity) {
                if (null != lastAct) {
                    //如果是相同activity,并且在150ms内跳转多次,则屏蔽多次跳转
                    if (time - lastForwardTime < 150 && activity == lastAct) {
                        flag = false;
                    }
                }
            }
            lastForwardTime = time;
            lastAct = activity;
            return flag;
        }
    
    

    设置基础跳转方法

    intent 跳转

        /**
         * 跳转至下一页面--intent跳转
         * 可以调系统相册等
         * @param packageContext context
         * @param intent intent
         */
        public void forwardActivity(Context packageContext, Intent intent) {
            if (checkForward(packageContext)) {
                packageContext.startActivity(intent);
            }
        }
    

    指定类名跳转

    /**
        * 跳转至下一页面
        *
        * @param packageContext context
        * @param cls class
        */
       public void forwardActivity(Context packageContext, Class<?> cls) {
           if (checkForward(packageContext)) {
               Intent intent = new Intent(packageContext, cls);
               packageContext.startActivity(intent);
           }
       }
    
    

    带参数跳转,这个参数可以是String,int,long,double,boolean 我只举一个String的例子

        /**
         * 跳转至下一页面, 传递 String参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, String extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    

    获取当前activity

     /**
         * 获取当前的 activity
         *
         * @return act
         */
        public Activity currentActivity() {
            if (activityStack == null || activityStack.isEmpty()) {
                return null;
            }
            return activityStack.lastElement();
        }
    

    Activity入栈,一般放在Base类的onCreate()方法里

        /**
         * 将该 activity 入画面栈
         *
         * @param activity act
         */
        public void pushActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<>();
            }
            if (activityStack.contains(activity)) {
                activityStack.remove(activity);
            }
            activityStack.add(activity);
        }
    

    返回上一个activity,相当于finish,并且这里做了一个防止空指针的保护

    
        /**
         * 返回上一个 activity
         */
        public void popActivity() {
            if (activityStack == null) {
                activityStack = new Stack<>();
                return;
            }
    
            if (activityStack.isEmpty()) {
                return;
            }
    
            Activity activity = activityStack.pop();
            if (activity != null) {
                if (!activity.isFinishing())
                    activity.finish();
            }
        }
    

    高级跳转

    返回上一个activity,并且上一个类的类名不为参数传过来的类名,一般在注册界面使用,就是说你注册成功之后,自动登录,调用这个方法后不会返回到登录页面。

        /**
         * 返回上一个 activity,并且上一个activity不为指定类名activity,否则继续pop
         */
        public void popActivity(Class<?> cls) {
            popActivity();
            if (isCurrentActivity(cls)) {
                popActivity();
            }
        }
    

    弹出activity 栈中的指定activity对象

        /**
         * 弹出画面栈中的某一个 activity
         *
         * @param activity 要弹出的 activity 对象
         */
        public void popActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<>();
            }
    
            if (activityStack.isEmpty()) {
                return;
            }
    
            if (activity != null) {
                activityStack.remove(activity);
                if (!activity.isFinishing())
                    activity.finish();
            }
        }
    

    清空activity栈,仅仅保留一个activit,一般用于快速回到首页,或者捕获异常时不退出app,而是跳转首页。

        /**
         * 弹出所有画面栈,仅保留某一个 activity
         *
         * @param cls 要保留的 activity 类
         */
        public void popAllActivityExceptOne(Class<?> cls) {
            while (true) {
                Activity activity = currentActivity();
                if (activity == null) {
                    break;
                }
                if (activity.getClass().equals(cls)) {
                    break;
                }
                popActivity(activity);
            }
        }
    
    

    在程序退出的时候清空一下activity栈

        /**
         * 清空画面栈,退出程序
         */
        public void popAllActivity() {
            //MobclickAgent.onKillProcess(currentActivity());//可以在这里加入友盟统计事件
            while (true) {
                Activity activity = currentActivity();
                if (activity == null) {
                    break;
                }
                popActivity(activity);
            }
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(0);
        }
    

    代码帮助类

    有一些不常用的方法我就不一一赘述了,下面我会把整个Actmanager类的代码贴出来,需要的尽管拿去,大家又不懂的可以在评论区向我提问。
    Github链接--https://github.com/EspressoToast/BaseTest

    package com.example.ljw.basedemo;
    
    import android.app.Activity;
    import android.content.Context;
    import android.content.Intent;
    
    
    import java.util.Calendar;
    import java.util.Stack;
    
    public class ActManager {
        private static Stack<Activity> activityStack;
        private static ActManager instance = new ActManager();
        private long lastForwardTime = 0;
        private Activity lastAct = null;
    
        private ActManager() {
        }
    
        public static ActManager Instance() {
            return instance;
        }
    
    
    
    
    
        /**
         * 防止页面短时间重复跳转
         *
         * @return true:可以跳转 false:不跳转
         */
        private boolean checkForward(Context context) {
            Activity activity = null;
            boolean flag = true;
            try {
                activity = (Activity) context;
            } catch (Exception e) {
                Logger.output("Warning!!! ApplicationContext");
                //说明是ApplicationContext
            }
    
            long time = Calendar.getInstance().getTimeInMillis();
            if (null != activity) {
                if (null != lastAct) {
                    //如果是相同activity,并且在150ms内跳转多次,则屏蔽多次跳转
                    if (time - lastForwardTime < 150 && activity == lastAct) {
                        flag = false;
                    }
                }
            }
            lastForwardTime = time;
            lastAct = activity;
            return flag;
        }
    
    
    
    
    
    
    
    
        /**
         * 跳转至下一页面
         *
         * @param packageContext context
         * @param intent intent
         */
        public void forwardActivity(Context packageContext, Intent intent) {
            if (checkForward(packageContext)) {
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面
         *
         * @param packageContext context
         * @param cls class
         */
        public void forwardActivity(Context packageContext, Class<?> cls) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面, 传递 String参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, String extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面, 传递 int 参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, int extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面, 传递 long 参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, long extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面, 传递 double 参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, double extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    
        /**
         * 跳转至下一页面, 传递 boolean 参数
         */
        public void forwardActivity(Context packageContext, Class<?> cls, String key, boolean extra) {
            if (checkForward(packageContext)) {
                Intent intent = new Intent(packageContext, cls);
                intent.putExtra(key, extra);
                packageContext.startActivity(intent);
            }
        }
    
            /**
             * 将该 activity 入画面栈
             *
             * @param activity act
             */
            public void pushActivity(Activity activity) {
                if (activityStack == null) {
                    activityStack = new Stack<>();
                }
                if (activityStack.contains(activity)) {
                    activityStack.remove(activity);
                }
                activityStack.add(activity);
            }
    
        /**
         * 返回上一个 activity
         */
        public void popActivity() {
            if (activityStack == null) {
                activityStack = new Stack<>();
                return;
            }
    
            if (activityStack.isEmpty()) {
                return;
            }
    
            Activity activity = activityStack.pop();
            if (activity != null) {
                if (!activity.isFinishing())
                    activity.finish();
            }
        }
    
        /**
         * 返回上一个 activity,并且上一个activity不为指定类名activity,否则继续pop
         */
        public void popActivity(Class<?> cls) {
            popActivity();
            if (isCurrentActivity(cls)) {
                popActivity();
            }
        }
    
        /**
         * 根据类名判断是否是当前activity
         */
        private boolean isCurrentActivity(Class<?> cls) {
            Activity currentActivity = currentActivity();
            if (null == currentActivity) {
                return false;
            }
    
            if (currentActivity.getClass().equals(cls)) {
                return true;
            }
            return false;
        }
    
        /**
         * 结束指定类名的Activity
         */
        public void finishActivity(Class<?> cls) {
            for (Activity activity : activityStack) {
                if (activity.getClass().equals(cls)) {
                    popActivity(activity);
                }
            }
        }
    
        /**
         * 弹出画面栈中的某一个 activity
         *
         * @param activity 要弹出的 activity 对象
         */
        public void popActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<>();
            }
    
            if (activityStack.isEmpty()) {
                return;
            }
    
            if (activity != null) {
                activityStack.remove(activity);
                if (!activity.isFinishing())
                    activity.finish();
            }
        }
    
        /**
         * 获取当前的 activity
         *
         * @return act
         */
        public Activity currentActivity() {
            if (activityStack == null || activityStack.isEmpty()) {
                return null;
            }
            return activityStack.lastElement();
        }
    
        /**
         * 清空画面栈,退出程序
         */
        public void popAllActivity() {
            while (true) {
                Activity activity = currentActivity();
                if (activity == null) {
                    break;
                }
                popActivity(activity);
            }
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(0);
        }
    
        /**
         * 清空画面栈,并且进入某一个页面
         */
        public void popAllActivityNoExit() {
            while (true) {
                Activity activityTemp = currentActivity();
                if (activityTemp == null) {
                    break;
                }
                popActivity(activityTemp);
            }
        }
    
        /**
         * 返回到指定 activity
         *
         * @param cls 指定的activity
         */
        public void backToActivity(Class<?> cls) {
            while (true) {
                Activity activity = currentActivity();
                if (activity == null) {
                    break;
                }
                if (activity.getClass().equals(cls)) {
                    return;
                }
                popActivity(activity);
            }
        }
    
        /**
         * 弹出所有画面栈,仅保留某一个 activity
         *
         * @param cls 要保留的 activity 类
         */
        public void popAllActivityExceptOne(Class<?> cls) {
            while (true) {
                Activity activity = currentActivity();
                if (activity == null) {
                    break;
                }
                if (activity.getClass().equals(cls)) {
                    break;
                }
                popActivity(activity);
            }
        }
    
        /**
         * 判断画面栈中是否存在该 activity 对象
         *
         * @param activity act
         * @return 存在返回TRUE ,不存在返回FALSE
         */
        public boolean existActivity(Activity activity) {
            if (activityStack == null) {
                activityStack = new Stack<>();
            }
    
            return !activityStack.isEmpty() && activityStack.contains(activity);
    
        }
    
        public boolean hasOtherActivity(Activity activity) {
            if (null == activityStack || activityStack.isEmpty()) {
                return false;
            }
    
            if (activityStack.size() > 1) {
                return true;
            } else if (activityStack.size() == 1) {
                return !activityStack.contains(activity);
            }
            return false;
        }
    
    }
    
    

    下一篇预告--Android 项目开发必备-Utils类的建立与使用

    相关文章

      网友评论

      • abb03331c168:看了您的文章很不错,支付宝急招,同学有兴趣么?可加我微信luofei-lf内部推荐
      • yunhen:大佬,问个问题,为啥要用stack,用list不行嘛?
        yunhen:@PaperKite 哦哦,谢谢大佬
        PaperKite:Stack 继承Vector ,Vector继承AbstractList。ArrayList继承AbstractList。本质上他俩差不多,但是Stack是java专门提供给你的堆栈类,压栈出栈都有方法,何必再去用list,建议你去看看他们的源码

      本文标题:Android 项目开发必备-Activity管理栈之Activ

      本文链接:https://www.haomeiwen.com/subject/nnxoixtx.html