记录一次APP弹窗排队的实践

前言

2022年11月11日。很吉利的日子，APP功能日益复杂，在首页的的弹窗就超过4个，分别是首页的引导，APP的更新弹窗，APP的协议更新弹窗，APP的广告弹窗，权限申请弹窗等。因为有些弹窗是通过dialog 去实现的，当网络较慢的情况下，就会出现一个问题，APP都切换到其他板块去了，dialog 却弹出来了。于是我们打算优化这一流程。

正文

我们先对业务诉求进行分析。

• 我们需要将这些弹窗固定在首页弹起。
• 弹窗的弹起是有一定的顺序的。
• 这些弹窗部分依赖于一个网络接口，
• 有的却是本地参数判断。

设计

定义需要获取到外部参数：

依次弹起，我们可以分析下，可以使用一个队列存储。因为队列是先进先出的嘛。在首页弹起的功能，我们可以获取到首页的生命周期对象 lifecycleOwner，有些弹窗是dialogFragment 实现的，所以需要一个fragmentManger,然后就是上下文了,同时我们期望外部可以接受到我们队列处理完成的监听。而这些都可以通过一个队列管理器去存储他。那么我们需要的参数就大致是这些：

 	 FragmentManager fragmentManager;
    LifecycleOwner lifecycleOwner;
    Consumer<Boolean> queueEndConsumer;

定义队列对象操作的接口

我们对也是诉求中的‘‘这些弹窗部分依赖于一个网络接口，有的却是本地参数判断’’，因为本地数据是可以主线程获取到，我们可以在添加到队列中之前判断是否添加到队列，然后是网络请求部分，网络请求时异步的，所以我们需要定义一个接口去标记他准备好了，为了使用简单化，我们将处理完成和不需要弹起弹窗的逻辑混为一谈，不需要弹起弹窗的逻辑就包含了，网络错误，网络成功后判断不需要弹，登录过期等等。

public interface ViewCallBack {
    /**
     * 准备完成
     */
    void ready(int position);

    /**
     * 结束操作。
     */
    void endHandle(int position);
}

为啥要返回一个position，在我的预想里面，是通过排序队列去做的，而不是通过数组顺序。实际上我却是用的数组顺序，通过排序队列是便于后期迭代，比如这期的登录过期弹窗就没有处理，我们登录过期弹窗是接口返回的，虽然也可以强行调用一个必须登录的接口判断是否登录过期，但是感觉怪怪的。

定义队列对象

队列对象需要负责提供是否添加到队列中，需要回调上面的操作接口，需要处理网络请求，本地逻辑，需要处理弹窗等等。

public abstract class ViewQueueItem {

    protected int position;
    protected ViewCallBack callBack;
    protected FragmentManager fragmentManager;
    protected LifecycleOwner lifecycleOwner;
    /**
     * 是否准备好了。
     */
    protected Boolean ready=false;
    /**
     * 是否已经完成
     */
    protected Boolean endHandle=false;

    public Boolean getEndHandle() {
        return endHandle;
    }

    public void setEndHandle(Boolean endHandle) {
        this.endHandle = endHandle;
    }

    public Boolean getReady() {
        return ready;
    }

    public void setReady(Boolean ready) {
        this.ready = ready;
    }

    public void setLifecycleOwner(LifecycleOwner lifecycleOwner) {
        this.lifecycleOwner = lifecycleOwner;
    }

    public void setFragmentManager(FragmentManager fragmentManager) {
        this.fragmentManager = fragmentManager;
    }

    /**
     * 有一些逻辑上不需要处理的。比如说APP 第一次安装启动。
     * 更新弹窗就不需要处理。协议更新弹窗也不需要处理。
     *
     * @return needHandle
     */
    public abstract boolean needHandle();

    /**
     * 设置监听回调
     *
     * @param callBack callBack
     */
    void setCallBack(ViewCallBack callBack) {
        this.callBack = callBack;
    }

    /**
     * 开始准备
     */
    public abstract void gettingReady();


    /**
     * 开始操作
     */
    public abstract void startHandle();


    /**
     * 获取到当前队列的位置。
     *
     * @param position position
     */
    void setPosition(int position) {
        this.position = position;
    }
}

可以看到，我依旧把下标丢进去了。

调用对象的设计

我们上面需要在首页显示的时候，才显示弹窗，所以我们单纯的使用MutableLiveData 即可。

队列管理器设计

在添加完队列之后，需要调用一个开始队列。我们将添加的class与真实的队列分开。开始的时候，开启一个循环，判断是否添加到队列中，然后在循环中设置一些队列实现类的基本参数，包括position（在我的设计中，position 是需要外部传入的，但是架不住砍需求）。

当一个队列对象准备好的时候，获取并判断队列头部的对象是否准备好，如果准备好了就调用显示方法，如果没有准备好，就继续等等，当一个对象通过逻辑判断认为他结束的时候，我们将他从队列中移除出去。

这么有一个需要注意的点就是，需要判断队列头部对象是否频繁调用显示函数。

完整代码：

public class ViewQueueManger extends ViewModel implements Observer<ViewQueueItem> {
    FragmentManager fragmentManager;
    LifecycleOwner lifecycleOwner;
    Consumer<Boolean> queueEndConsumer;
    /**
     * 这个用来存储之前的队列。
     */
    List<ViewQueueItem> queueItems = new ArrayList<>();

    MutableLiveData<ViewQueueItem> queueLive = new MutableLiveData<>();
    /**
     * 这个是排序队列。
     */
    PriorityQueue<ViewQueueItem> queue = new PriorityQueue<>(10, (o1, o2) -> o1.position - o2.position);

    public ViewQueueManger addQueue(ViewQueueItem queueItem) {
        queueItems.add(queueItem);
        return this;
    }
    public ViewQueueManger setFragmentManager(FragmentManager fragmentManager) {
        this.fragmentManager = fragmentManager;
        return this;
    }

    public ViewQueueManger setLifecycleOwner(LifecycleOwner lifecycleOwner) {
        this.lifecycleOwner = lifecycleOwner;
        queueLive.observe(lifecycleOwner, this);
        return this;
    }



    public ViewQueueManger setQueueEndConsumer(Consumer<Boolean> queueEndConsumer) {
        this.queueEndConsumer = queueEndConsumer;
        return this;
    }



    /**
     *
     */
    public void start() {
        int index = 0;
        for (ViewQueueItem item : queueItems) {
            // 设置下标。
            if (item.needHandle()) {
                item.setPosition(index);
                item.setLifecycleOwner(lifecycleOwner);
                item.setFragmentManager(fragmentManager);
                // 直接丢进队列。
                LogUtils.e("添加进入队列：" + item.getClass().getName());
                queue.add(item);
                index++;
                item.setCallBack(new ViewCallBack() {
                    @Override
                    public void ready(int position) {
                        item.setReady(true);
                        LogUtils.e("ready:" + position + "  " + item.getClass().getName());
                        doQueue();
                    }

                    @Override
                    public void endHandle(int position) {
                        item.setEndHandle(true);
                        LogUtils.e("endHandle:" + position + "  " + item.getClass().getName());
                        // 移除当前完成的本身
                        if (queue.contains(item)) {
                            queue.remove(item);
                            LogUtils.e("移除已经结束的内容" + item.getClass().getName());
                        }
                        // 然后获取下一个。
                        doQueue();

                    }
                });
                // 开始准备
                item.gettingReady();
            }
        }
    }

    private void doQueue() {
        if (queue.size() > 0) {
            // 获取头部的数据。如果准备好了就操心。
            ViewQueueItem element = queue.element();
            // 准备完成，并且没有操作完。
            if (element.getReady() && !element.getEndHandle()) {
                if (null == queueLive.getValue()) {
                    queueLive.postValue(element);
                    LogUtils.e("发送展示要求：" + element.getClass().getName());
                } else if (queueLive.getValue() != null && queueLive.getValue() != element) {
                    queueLive.postValue(element);
                    LogUtils.e("发送展示要求：" + element.getClass().getName());
                }
            }
        }else {
            LogUtils.e("---------------");
            if (null!=queueEndConsumer){
                queueEndConsumer.accept(true);
            }
        }
    }


    @Override
    public void onChanged(ViewQueueItem viewQueueItem) {
        // 接受到需要显示的消息。
        viewQueueItem.startHandle();
    }
}

总结

其实，这就是对于队列的一种单纯的使用，这种想法萌生已久，需要注意的是ViewQueueItem的实现类必须逻辑严谨，必须调用准备好了或者结束的函数。

写完后才发现，这个调调 不仅仅是处理界面，可以处理一系列需要排队的诉求，也可以把权限相关的加进来。