Android 如何实现弹窗顺序&优先级控制

一般在项目首页中,往往会有多个对话框需要弹出,比如活动弹窗、更新弹窗、评分弹窗等等,而且这些弹窗是有优先级顺序的。这些弹窗一般是通过接口请求后返回结果再显示的,如果只有几个弹窗还好处理,业务逻辑上判断一下先后显示就可以。如果有十几个或者更多,那么处理起来将非常麻烦,而且容易出现问题。

所以封装一个可以按照优先级顺序显示的弹窗功能就非常有必要,首先功能需求如下:

  • 按优先级顺序阻塞式显示各种类型弹窗,默认从最高优先级开始显示
  • 只有上一个高优先级弹窗显示完或者取消显示,下一个低优先级弹窗才可以显示
  • 指定显示某一个弹窗的前提是没有更高优先级的弹窗需要显示
  • 在显示一个弹窗之前需要判断是否能够或者需要显示
  • 根据优先级去查找指定的弹窗,优先级相当于唯一ID
  • 弹窗包括多种类型,Dialog、PopupWindow、Activity等等

接着开始编码去实现功能,先定一个枚举类,罗列出支持的弹窗类型,包括Dialog、PopupWindow、Activity等等。

public enum WindowType {

  DIALOG,
  POUPOWINDOW,
  TOAST,
  SNACKBAR,
  WIDGET,
  ACTIVITY,
  OTHERS

}

然后定义弹窗接口IWindow,它定义了弹窗的基本功能。

/**
* 窗口约定规则
*/
public interface IWindow {

  /**
   * 弹窗展示
   */
  void show(Activity activity);

  /**
   * 弹窗关闭
   */
  void dismiss();

  /**
   * 设置窗口关闭监听
   */
  void setOnWindowDismissListener(OnWindowDismissListener listener);

  /**
   * 设置窗口展示监听
   */
  void setOnWindowShowListener(OnWindowShowListener listener);

}

以及弹窗显示和关闭的监听接口,

/**
* 窗口关闭监听
*/
public interface OnWindowDismissListener {

  /**
   *
   */
  void onDismiss();

}

/**
* 窗口展示监听
*/
public interface OnWindowShowListener {

  void onShow();

}

接下来定义个包裹类WindowWrapper去封装弹窗相关的属性和状态,包括弹窗、优先级、能否显示、窗体类型等等,在处理弹窗显示逻辑时将会用到。

/**
* 窗口参数类
*/
public class WindowWrapper {

  /**
   * 窗口
   */
  private IWindow mWindow;

  /**
   * 优先级,值越大优先级越高
   */
  private int mPriority;

  /**
   * 当前是否处于show状态
   */
  private boolean isShowing;

  /**
   * 是否满足show的条件
   */
  private boolean isCanShow;

  /**
   * 弹窗类型
   */
  private WindowType mWindowType;

  /**
   * 弹窗名称
   */
  private String mWindowName;

  private WindowWrapper(Builder builder) {
    mWindow = builder.window;
    mPriority = builder.priority;
    mWindowType = builder.windowType;
    isCanShow = builder.isCanShow;
    mWindowName = builder.windowName;
  }

  public IWindow getWindow() {
    return mWindow;
  }

  public void setWindow(IWindow window) {
    this.mWindow = window;
  }

  public int getPriority() {
    return mPriority;
  }

  public void setPriority(int priority) {
    this.mPriority = priority;
  }

  public boolean isShowing() {
    return isShowing;
  }

  public void setShowing(boolean showing) {
    isShowing = showing;
  }

  public WindowType getWindowType() {
    return mWindowType;
  }

  public void setWindowType(WindowType mWindowType) {
    this.mWindowType = mWindowType;
  }

  public boolean isCanShow() {
    return isCanShow;
  }

  public void setCanShow(boolean canShow) {
    isCanShow = canShow;
  }

  public String getWindowName() {
    return mWindowName;
  }

  public void setWindowName(String mWindowName) {
    this.mWindowName = mWindowName;
  }

  public static class Builder {

    /**
     * 窗口
     */
    private IWindow window;

    /**
     * 优先级,值越大优先级越高
     */
    private int priority;

    /**
     * 弹窗类型
     */
    private WindowType windowType;

    /**
     * 是否满足show的条件
     */
    private boolean isCanShow;

    /**
     * 弹窗名称
     */
    private String windowName;

    public Builder window(IWindow window) {
      this.window = window;
      return this;
    }

    public Builder priority(int priority) {
      this.priority = priority;
      return this;
    }

    public Builder windowType(WindowType type) {
      this.windowType = type;
      return this;
    }

    public Builder setCanShow(boolean canShow) {
      isCanShow = canShow;
      return this;
    }

    public String getWindowName() {
      return windowName;
    }

    public Builder setWindowName(String windowName) {
      this.windowName = windowName;
      return this;
    }

    public WindowWrapper build() {
      return new WindowWrapper(this);
    }
  }
}

最后通过WindowTaskManager类去统一组织管理弹窗的添加、显示、关闭等逻辑,

public class WindowTaskManager {
  private List<WindowWrapper> mWindows;

  private static WindowTaskManager mDefaultInstance;

  private WindowTaskManager() {
  }

  /**
   * 获取弹窗管理者
   */
  public static WindowTaskManager getInstance() {
    if (mDefaultInstance == null) {
      synchronized (WindowTaskManager.class) {
        if (mDefaultInstance == null) {
          mDefaultInstance = new WindowTaskManager();
        }
      }
    }
    return mDefaultInstance;
  }

  /**
   * 添加弹窗
   *
   * @param windowWrapper 待显示的弹窗
   */
  public synchronized void addWindow(Activity activity, WindowWrapper windowWrapper) {
    if (windowWrapper != null) {
      if (mWindows == null) {
        mWindows = new ArrayList<>();
      }

      if (windowWrapper.getWindow() != null) {
        windowWrapper.getWindow().setOnWindowShowListener(new OnWindowShowListener() {
          @Override
          public void onShow() {
            windowWrapper.setShowing(true);
          }
        });

        windowWrapper.getWindow().setOnWindowDismissListener(new OnWindowDismissListener() {
          @Override
          public void onDismiss() {
            windowWrapper.setShowing(false);
            mWindows.remove(windowWrapper);
            showNext(activity);
          }
        });
      }

      mWindows.add(windowWrapper);
    }
  }

  /**
   * 弹窗满足展示条件
   *
   * @param priority
   */
  public synchronized void enableWindow(Activity activity, int priority, IWindow window) {
    WindowWrapper windowWrapper = getTargetWindow(priority);
    if (windowWrapper != null) {

      if (windowWrapper.getWindow() == null) {
        window.setOnWindowShowListener(new OnWindowShowListener() {
          @Override
          public void onShow() {
            windowWrapper.setShowing(true);
          }
        });

        window.setOnWindowDismissListener(new OnWindowDismissListener() {
          @Override
          public void onDismiss() {
            windowWrapper.setShowing(false);
            mWindows.remove(windowWrapper);
            showNext(activity);
          }
        });
      }

      windowWrapper.setCanShow(true);
      windowWrapper.setWindow(window);
      show(activity, priority);
    }
  }

  /**
   * 移除不需要显示弹窗
   *
   * @param priority
   */
  public synchronized void disableWindow(int priority) {
    WindowWrapper windowWrapper = getTargetWindow(priority);
    if (windowWrapper != null && windowWrapper.getWindow() != null) {
      if (mWindows != null) {
        mWindows.remove(windowWrapper);
      }
    }
  }

  /**
   * 展示弹窗
   * 从优先级最高的Window开始显示
   */
  public synchronized void show(Activity activity) {
    WindowWrapper windowWrapper = getMaxPriorityWindow();
    if (windowWrapper != null && windowWrapper.isCanShow()) {
      IWindow window = windowWrapper.getWindow();
      if (window != null) {
        window.show(activity);
      }
    }
  }

  /**
   * 显示指定的弹窗
   *
   * @param priorities
   */
  public synchronized void show(Activity activity, int priorities) {
    WindowWrapper windowWrapper = getTargetWindow(priorities);
    if (windowWrapper != null && windowWrapper.getWindow() != null) {
      WindowWrapper topShowWindow = getShowingWindow();
      if (topShowWindow == null) {
        int priority = windowWrapper.getPriority();
        WindowWrapper maxPriorityWindow = getMaxPriorityWindow();
        if (maxPriorityWindow != null && windowWrapper.isCanShow() && priority >= maxPriorityWindow.getPriority()) {
          if (windowWrapper.getWindow() != null) {
            windowWrapper.getWindow().show(activity);
          }
        }
      }
    }
  }

  /**
   * 清除弹窗管理者
   */
  public synchronized void clear() {
    if (mWindows != null) {
      for (int i = 0, size = mWindows.size(); i < size; i++) {
        if (mWindows.get(i) != null) {
          IWindow window = mWindows.get(i).getWindow();
          if (window != null) {
            window.dismiss();
          }
        }
      }
      mWindows.clear();
    }
    WindowHelper.getInstance().onDestroy();
  }

  /**
   * 清除弹窗管理者
   *
   * @param dismiss 是否同时dismiss掉弹窗管理者维护的弹窗
   */
  public synchronized void clear(boolean dismiss) {
    if (mWindows != null) {
      if (dismiss) {
        for (int i = 0, size = mWindows.size(); i < size; i++) {
          if (mWindows.get(i) != null) {
            IWindow window = mWindows.get(i).getWindow();
            if (window != null) {
              window.dismiss();
            }
          }
        }
      }
      mWindows.clear();
    }
    WindowHelper.getInstance().onDestroy();
  }

  /**
   * 展示下一个优先级最大的Window
   */
  private synchronized void showNext(Activity activity) {
    WindowWrapper windowWrapper = getMaxPriorityWindow();
    if (windowWrapper != null && windowWrapper.isCanShow()) {
      if (windowWrapper.getWindow() != null) {
        windowWrapper.getWindow().show(activity);
      }
    }
  }

  /**
   * 获取当前栈中优先级最高的Window(优先级相同则返回后添加的弹窗)
   */
  private synchronized WindowWrapper getMaxPriorityWindow() {
    if (mWindows != null) {
      int maxPriority = -1;
      int position = -1;
      for (int i = 0, size = mWindows.size(); i < size; i++) {
        WindowWrapper windowWrapper = mWindows.get(i);
        if (i == 0) {
          position = 0;
          maxPriority = windowWrapper.getPriority();
        } else {
          if (windowWrapper.getPriority() >= maxPriority) {
            position = i;
            maxPriority = windowWrapper.getPriority();
          }
        }
      }
      if (position != -1) {
        return mWindows.get(position);
      } else {
        return null;
      }
    }
    return null;
  }

  private synchronized WindowWrapper getTargetWindow(int priority) {
    if (mWindows != null) {
      for (int i = 0, size = mWindows.size(); i < size; i++) {
        WindowWrapper windowWrapper = mWindows.get(i);
        if (windowWrapper != null && windowWrapper.getPriority() == priority) {
          return windowWrapper;
        }
      }
    }
    return null;
  }

  /**
   * 获取当前处于show状态的弹窗
   */
  private synchronized WindowWrapper getShowingWindow() {
    if (mWindows != null) {
      for (int i = 0, size = mWindows.size(); i < size; i++) {
        WindowWrapper windowWrapper = mWindows.get(i);
        if (windowWrapper != null && windowWrapper.getWindow() != null && windowWrapper.isShowing()) {
          return windowWrapper;
        }
      }
    }
    return null;
  }

}

WindowTaskManager类有三个主要方法:

  • addWindow(Activity activity, WindowWrapper windowWrapper)
  • enableWindow(Activity activity, int priority, IWindow window)
  • disableWindow(int priority)

需要按顺序显示的对话框统一使用addWindow方法添加,这是还未进行网络请求之前就要调用的。作用是告诉WindowTaskManager一共有多少个弹窗需要按顺序显示。当网络请求返回之后,如果需要显示弹窗就调用enableWindow方法去显示,如果不需要显示弹窗就调用disableWindow方法,将这个弹窗从显示队列中移除。

以上就是按顺序显示弹窗的主要逻辑,使用的话窗体先继承IWindow,实现相关方法。然后通过操作WindowTaskManager类就可以了。具体使用方法参见源码。

项目地址:github.com/Geekince/Pr…

彩蛋:

需要在DialogFragment中显示DialogFragment时候,最好不要直接在DialogFragment启动显示,而是在DialogFragment的消失回调中启动显示。因为当前一个DialogFragment消失的时候,getChildFragmentManager可能会失效,应该在外层使用getFragmentManager。

以上就是Android 如何实现弹窗顺序&优先级控制的详细内容,更多关于Android 实现弹窗顺序和优先级控制的资料请关注我们其它相关文章!

时间: 2021-03-30

android dialog根据弹窗等级排序显示的示例代码

背景:由于主界面可能弹窗很多弹窗,需求要求某个dialog必须在前面显示,如果再消失监听中,线性判断,每个dialog都去判断工作量巨大,且不易阅读.所以做了一个弹窗排序的项目.这里只是讲解单个activity中的弹窗排序,demo中还有维护多个activity 弹窗排序,详细看最下面github 做到工具组件化,不侵入原项目代码,无需继承,使用方便. 原理:当有一个dialog添加显示时,判断等级是否大于,大于则显示,否则则添加到等待队列 private void show(int level

Android 7.0 运行时权限弹窗问题的解决

Android 7.0系统在运行应用的时候,对权限做了诸多限制,normal, dangerous, signature, signatureOrSystem ,取决于保护级别,在确定是否授予权限时,系统可能采取不同的操作. normal 表示权限是低风险的,不会对系统.用户或其他应用程序造成危害: dangerous 表示权限是高风险的,系统将可能要求用户输入相关信息,才会授予此权限: signature 表示只有当应用程序所用数字签名与声明引权限的应用程序所用数字签名相同时,才能将权限授给它

Android单一实例全局可调用网络加载弹窗

最近因为项目需求,需要完成一个全局的网络加载弹窗需求,真正完成这个需求之后,感觉最重要的不是结果,而是思维. 我刚开始接到这个需求的时候,第一种想到的方案是 基类加单例.但是实际做起来之后发现,因为单例的原因,你的弹窗只能在第一次创建这个单例的activity中显示出来. 那么发现这个问题之后在这个的基础上改进一下,如果我不用activity的上下文,而是采用类似于Application的一种全局上下文呢?当然,个人能力有限,这种想法就给毙掉了,后来由导师指点,利用service的上下文,dia

Android自定义弹窗提醒控件使用详解

Android中原生的Dialog弹窗提醒控件样式单一,有时候并不能满足我们的项目需求,而且一个工程里面有时候会在多处都用到弹窗提醒的功能,代码会出现大量的冗余,工作之余,就自己实现了这么一个弹窗提醒控件.自定义控件继承自我们的Dialog,样式自定义,弹窗中的文字可通过数组参数初始化,Item个数实现了动态添加,和数组长度一致.对话框底端可展示一个Item(如:确定)或两个Item(如:确定   取消),通过参数设置.废话不多说,直接上代码: 1.自定义对话框的背景样式,在res/values

Android开发实现仿京东商品搜索选项卡弹窗功能

本文实例讲述了Android开发实现仿京东商品搜索选项卡弹窗功能.分享给大家供大家参考,具体如下: 一.效果图: 二.思路: (1)首先顶部布局由通过LinearLayout水平按比重平均分配各个item宽度. (2)每个item设置两种状态,点击状态与未点击状态 (3)弹窗由PopupWindow实现 三.布局 (1)item布局 <!-- 优先筛选条件布局 --> <RelativeLayout android:id="@+id/rl_priority_filter&quo

Android Q之气泡弹窗的实现示例

在Android Q中,用户可以借助气泡,轻松地在设备上任何位置进行多任务处理.气泡内置于"通知"系统中,它会浮动在其他应用的上层,并会跟随用户的移动而移动到屏幕的任何位置,用于取代SYSTEM_ALERT_WINDOW.气泡可以展开显示应用功能和信息,并在不使用时折叠起来.当设备处于已锁定状态或始终保持活动状态,气泡会像通知那样显示.气泡弹窗效果如下图: 一.气泡配置信息  气泡是一种可以选择停用的功能,在应用显示第一个气泡时,系统会弹出权限对话框,提供两种选项: 屏蔽来自您的应用的

Android使用 PopupWindow 实现底部弹窗功能

一.知识点 不详细展开 PopupWindow 或者视图动画的所有具体使用方式,仅仅介绍一下使用的一个大概流程和一些知识要点,具体的介绍在下面设计实现中讲述 (一)PopupWindow 1. 初始化 加载弹窗的布局 实例化 PopupWindow 传入布局和弹窗的宽高 对布局里面的控件的操作 对布局本身的一些设置 // 加载弹窗的布局 pwView = LayoutInflater.from(this).inflate(R.layout.pw_search_engine, null, fals

Android实现自适应屏幕的弹窗广告

本文实例为大家分享了Android实现弹窗广告的具体代码,供大家参考,具体内容如下 内容:弹窗广告 特点:根据屏幕尺寸和原图片比例自适应 代码如下: package com.example.leixiansheng.addialog; import android.annotation.SuppressLint; import android.app.Dialog; import android.content.Context; import android.content.Intent; im

Android 自定义加载动画Dialog弹窗效果的示例代码

效果图 首先是创建弹窗的背景 这是上面用到的 以shape_bg_5_blue.xml为例,其他的三个无非就是里面的颜色不一样而已 <?xml version="1.0" encoding="utf-8"?> <shape xmlns:android="http://schemas.android.com/apk/res/android"> <corners android:radius="5dp"

Android自定义加载圈动画效果

本文实例为大家分享了Android自定义加载圈动画展示的具体代码,供大家参考,具体内容如下 实现如下效果: 该效果图主要有3个动画: 1.旋转动画 2.聚合动画 3.扩散动画 以上3个动画都是通过ValueAnimator来实现,配合自定义View的onDraw()方法实现不断的刷新和绘制界面. 具体代码如下: package blog.csdn.net.mchenys.myanimationloading; import android.animation.Animator; import a

Android自定义加载控件实现数据加载动画

本文实例为大家分享了Android自定义加载控件,第一次小人跑动的加载效果眼前一亮,相比传统的PrograssBar高大上不止一点,于是走起,自定义了控件LoadingView去实现动态效果,可直接在xml中使用,具体实现如下 package com.*****.*****.widget; import android.content.Context; import android.graphics.drawable.AnimationDrawable; import android.util.

Android实现加载状态视图切换效果

关于Android加载状态视图切换,具体内容如下 1.关于Android界面切换状态的介绍 怎样切换界面状态?有些界面想定制自定义状态?状态如何添加点击事件?下面就为解决这些问题! 内容界面 加载数据中 加载数据错误 加载后没有数据 没有网络 2.思路转变,抽取分离类管理几种状态 以前做法: 直接把这些界面include到main界面中,然后动态去切换界面,后来发现这样处理不容易复用到其他项目中,而且在activity中处理这些状态的显示和隐藏比较乱 利用子类继承父类特性,在父类中写切换状态,但

一款超酷的Android自定义加载控件

在设计应用的时候,我们应该热爱极简主义,简单就是好的,对于很多用户来说,复杂的东西并不受欢迎. 我要实现的是根据不同的情况去显示不同的加载效果,随用随调,效果是借鉴于某一项目的效果,我认为有必要提取出来改善封装一下,供以后使用.情况大致分为:加载中.无网络.无数据.加载失败等,这些仅仅就需要一个View 就可以搞定啦! 预览下效果图: 我们怎么实现这种效果呢 view_loading.xml的布局如下: <?xml version="1.0" encoding="utf

Android自定义加载loading view动画组件

在github上找的一个有点酷炫的loading动画https://github.com/Fichardu/CircleProgress 我写写使用步骤 自定义view(CircleProgress )的代码 package com.hysmarthotel.view; import com.hysmarthotel.roomcontrol.R; import com.hysmarthotel.util.EaseInOutCubicInterpolator; import android.ani

Ext GridPanel加载完数据后进行操作示例代码

比如load数据之后选定某些行数据. this相当于当前的GridPanel, idxs相当于你要选中的行号 复制代码 代码如下: this.store.on("load",function(store) { this.getSelectionModel().selectRows(idxs); //this.selectedRows = []; },this);

Angular4如何自定义首屏的加载动画详解

前言 相信大家都知道,在默认情况下,Angular应用程序在首次加载根组件时,会在浏览器的显示一个loading... 我们可以轻松地将loading修改成我们自己定义的动画.下面话不多说,来一起看看详细的介绍: 这是我们要实现首次加载的效果: 根组件标签中的内容 请注意:在你的入口文件index.html中,默认的loading...只是插入到根组件标签之间: <!doctype html> <html> <head> <meta charset="u

如何使用Flutter实现58同城中的加载动画详解

前言 在应用中执行耗时操作时,为了避免界面长时间等待造成假死的现象,往往会添加一个加载中的动画来提醒用户,在58同城中也不例外,而且我们并没有使用系统默认的加载动画,而是制作了一个具有58特色的加载动画. 在本篇文章中,给大家分享下笔者使用Flutter实现58同城中加载动画的过程.先看一下加载动画的效果: 动画效果乍看比较复杂,难以看出端倪,其实我们可以先调慢动画的速度,这样能够比较清晰地分析出动画的流程. 动画的流程 动画由两个圆弧的动效组成,两个圆弧的起始点角度和扫过的弧度随着时间规律变化

微信小程序实现自定义加载图标功能

效果图 实现思路 1.首先通过HTML+CSS实现加载动画的静态效果: 2.根据需求给每个动画设计不同的动画效果. 例如第一个加载图标的静态绘制 1.首先确定动画的盒子宽高: 2.设置盒子中每一个长方形的宽高以及定位(注意:此处需要将长方形的旋转中心点移动到长方形的右侧边终点,方便后期以该点旋转.): 3.通过长方形盒子的伪元素,设置显示的长方形背景和宽高,同时进行定位. 4.由于在第二步的时候,已经将旋转中心移动,此处我们直接对每一个盒子中长方形进行旋转(注意:旋转角度 = 360 / 盒子中