Android笔记(三十五)：用责任链模式封装一个App首页Dialog管理工具

🕗 发布于 2024-11-07 08:04 android 笔记责任链模式 kotlin Dialog

背景

项目需要在首页弹一系列弹窗，每个弹窗是否弹出都有自己的策略，以及哪个优先弹出，哪个在上一个关闭后再弹出，为了更好管理，于是封装了一个Dialog管理工具

效果

在这里插入图片描述

整体采用责任链模块设计，控制优先级及弹出策略

原理分析

每个弹窗都当做一个节点Node，抽象出一些公共接口

public interface Node {
    int getId();

    String getTag();

    void complete();

    void error(ChainException e);
}

定义弹窗的状态
INIT：初始创建
PROGRESS：开始弹出
COMPLETE：完成弹出到关闭的流程
ERROR：弹出错误

public interface Operation {
    State.INIT INIT = new State.INIT();
    State.PROGRESS PROGRESS = new State.PROGRESS();
    State.COMPLETE COMPLETE = new State.COMPLETE();

    abstract class State {
        State() {
        }

        public static final class INIT extends State {
            private INIT() {
                super();
            }

            @Override
            @NonNull
            public String toString() {
                return "INIT";
            }
        }

        public static final class PROGRESS extends State {
            private PROGRESS() {
                super();
            }

            @Override
            @NonNull
            public String toString() {
                return "PROGRESS";
            }
        }

        public static final class COMPLETE extends State {
            private COMPLETE() {
                super();
            }

            @Override
            @NonNull
            public String toString() {
                return "COMPLETE";
            }
        }

        public static final class ERROR extends State {

            private final Throwable mThrowable;

            public ERROR(@NonNull Throwable exception) {
                super();
                mThrowable = exception;
            }

            @NonNull
            public Throwable getThrowable() {
                return mThrowable;
            }

            @Override
            @NonNull
            public String toString() {
                return String.format("ERROR (%s)", mThrowable.getMessage());
            }
        }
    }
}

为Dialog节点定义具体的状态切换

public class DialogNode implements Node {
    private static final String TAG = "ChainNode";
    private int id;
    private String tag;
    private Operation.State state = Operation.INIT;
    private Executor executor;
    private CallBack callBack;

    private DialogNode(int id, String tag, Executor executor) {
        this.id = id;
        this.tag = tag;
        this.executor = executor;
    }

    public static DialogNode create(int id, Executor executor) {
        return create(id, TAG + id, executor);
    }

    public static DialogNode create(int id, String tag, Executor executor) {
        return new DialogNode(id, tag, executor);
    }

    @Override
    public void complete() {
        setState(Operation.COMPLETE);
        if (callBack != null) {
            callBack.onComplete();
        }
    }

    @Override
    public void error(ChainException e) {
        setState(Operation.COMPLETE);
        if (callBack != null) {
            callBack.onError(e);
        }
    }

    public void process(CallBack callBack) {
        this.callBack = callBack;
        if (executor != null) {
            executor.execute(this);
        }
    }

    public static String getTAG() {
        return TAG;
    }

    @Override
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public Executor getExecutor() {
        return executor;
    }

    public void setExecutor(Executor executor) {
        this.executor = executor;
    }

    public CallBack getCallBack() {
        return callBack;
    }

    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
    }

    public Operation.State getState() {
        return state;
    }

    public void setState(Operation.State state) {
        this.state = state;
    }

    @Override
    public String toString() {
        return "ChainNode{" +
                "id=" + id +
                ", tag='" + tag + '\'' +
                ", state=" + state +
                ", executor=" + executor +
                ", callBack=" + callBack +
                '}';
    }

    public interface CallBack {
        void onComplete();

        void onError(ChainException e);
    }
}

抽象DialogNode的构建工厂类，弹窗链上每个Dialog必须继承该类，并实现createDialog方法返回具体的业务Dialog；实现execute方法控制弹窗是否要弹出，以及通知工具什么时候完成弹出到关闭的流程

abstract class MDialogNodeCreator {
    protected var nodeDialog: Dialog? = null

    fun build(context: Context, dialogId: Int): DialogNode? {
        nodeDialog = createDialog(context)
        val node = DialogNode.create(dialogId) { node ->
            execute(node)
        }
        return node
    }

    /**
     * 构造一个对话框
     */
    abstract fun createDialog(context: Context): Dialog

    /**
     * 在此执行业务弹窗逻辑
     */
    abstract fun execute(node: Node)
}

ChainProcessor核心类，保存了每一个DialogNode，在调用start后开始从队列里面去头节点，当DialogNode回调onComplete后递归取下一个节点，直到队列尾部

public class ChainProcessor {
    private final SparseArray<DialogNode> nodeArrays;
    private final Builder builder;

    private ChainProcessor(SparseArray<DialogNode> nodeArrays, Builder builder) {
        this.nodeArrays = nodeArrays;
        this.builder = builder;
    }

    public void start() {
        if (nodeArrays == null || nodeArrays.size() <= 0) {
            Log.e("zbm111", "nodeArrays == null || nodeArrays.size <= 0");
            return;
        }
        startNode(nodeArrays.keyAt(0));
    }

    private void startNode(int nodeId) {
        int index = nodeArrays.indexOfKey(nodeId);
        DialogNode node = nodeArrays.valueAt(index);
        if (node != null && node.getState() == Operation.INIT) {
            node.setState(Operation.PROGRESS);
            node.process(new DialogNode.CallBack() {
                @Override
                public void onComplete() {
                    nextNode(index);
                }

                @Override
                public void onError(ChainException e) {
                    cancel();
                }
            });
        }
    }

    private void nextNode(int index) {
        //移除执行过的第一个
        removeNode(index);
        if (nodeArrays != null && nodeArrays.size() > 0) {
            startNode(nodeArrays.keyAt(0));
        }
    }

    private void removeNode(int index) {
        if (nodeArrays != null && nodeArrays.size() > 0) {
            nodeArrays.removeAt(index);
        }
    }

    private void cancel() {
        if (nodeArrays != null && nodeArrays.size() > 0) {
            nodeArrays.clear();
        }
    }

    public Builder getBuilder() {
        return builder;
    }

    public static class Builder {
        private final SparseArray<DialogNode> nodeArrays;
        private String tag;

        public Builder() {
            this.nodeArrays = new SparseArray<>();
        }

        public Builder addNode(DialogNode node) {
            if (node != null) {
                nodeArrays.append(node.getId(), node);
                if (TextUtils.isEmpty(tag)) {
                    tag = UUID.randomUUID().toString();
                }
                node.setTag(tag);
            }
            return this;
        }

        public Builder addNodes(DialogNode... nodes) {
            if (nodes != null && nodes.length > 0) {
                for (DialogNode node : nodes) {
                    addNode(node);
                }
            }
            return this;
        }

        public Builder addTag(String tag) {
            this.tag = tag;
            return this;
        }

        public ChainProcessor build() {
            checkTag();
            return new ChainProcessor(nodeArrays, this);
        }

        private void checkTag() {
            if (nodeArrays.size() > 0) {
                if (TextUtils.isEmpty(tag)) {
                    tag = UUID.randomUUID().toString();
                }
                for (int i = 0; i < nodeArrays.size(); i++) {
                    nodeArrays.get(nodeArrays.keyAt(i)).setTag(tag);
                }
            }
        }

        public String getTag() {
            return tag;
        }

        public SparseArray<DialogNode> getNodes() {
            return nodeArrays;
        }
    }
}

工具外部接口，主要是构建ChainProcessor，支持处理多个弹窗链

bject MDialogChainHelper {
    private val chainNodeMap = mutableMapOf<String, ChainProcessor>()

    private fun build(chainProcessor: ChainProcessor) {
        if (chainNodeMap.containsKey(chainProcessor.builder.tag)) {
            chainNodeMap.remove(chainProcessor.builder.tag)
        }
        chainNodeMap[chainProcessor.builder.tag] = chainProcessor
    }

    fun startDialogChain(tag: String) {
        chainNodeMap[tag]?.start()
    }

    private fun clearAllChain() {
        chainNodeMap.clear()
    }

    private fun clearDialogChain(tag: String): ChainProcessor? {
        return chainNodeMap.remove(tag)
    }

    fun addDialogChain(tag: String): ChainProcessor {
        val chainProcessor = ChainProcessor.Builder().addTag(tag).build()
        if (chainNodeMap.containsKey(chainProcessor.builder.tag)) {
            chainNodeMap.remove(chainProcessor.builder.tag)
        }
        chainNodeMap[chainProcessor.builder.tag] = chainProcessor
        return chainProcessor
    }

    fun getDialogChain(tag: String): ChainProcessor? {
        return chainNodeMap[tag]
    }

}

Demo验证

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        MDialogChainHelper.run {
            addDialogChain("test_main")
                .builder
                .addNode(OneDialogNode().build(this@MainActivity, 0))
                .addNode(TwoDialogNode().build(this@MainActivity, 1))
            startDialogChain("test_main"    )
        }
    }
}

class OneDialogNode: MDialogNodeCreator() {

    override fun createDialog(context: Context): Dialog {
        val dialog = Dialog(context)
        dialog.setContentView(R.layout.dialog_one)
        dialog.findViewById<View>(R.id.tv_title)?.setOnClickListener {
            dialog.dismiss()
        }
        dialog.window?.setLayout(WindowManager.LayoutParams.WRAP_CONTENT, WindowManager.LayoutParams.WRAP_CONTENT)
        return dialog
    }

    override fun execute(node: Node) {
        nodeDialog?.setOnDismissListener {
            node.complete()
            nodeDialog = null
        }
        nodeDialog?.show()
    }
}

class TwoDialogNode: MDialogNodeCreator() {

    override fun createDialog(context: Context): Dialog {
        val dialog = Dialog(context)
        dialog.setContentView(R.layout.dialog_two)
        dialog.findViewById<View>(R.id.tv_title)?.setOnClickListener {
            dialog.dismiss()
        }
        dialog.window?.setLayout(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)
        return dialog
    }

    override fun execute(node: Node) {
        nodeDialog?.setOnDismissListener {
            node.complete()
            nodeDialog = null
        }
        nodeDialog?.show()
    }
}

完整代码点击下载

大家觉得不错的点个赞鼓励下哦，有任何建议欢迎留言，谢谢🌹

原文地址：https://blog.csdn.net/weixin_40855673/article/details/143561469

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Python毕业设计选题：基于django+vue的论坛BBS系统
下一篇：腾讯混元3D-1.0：文本到三维和图像到三维生成的统一框架

无人机之姿态融合算法篇
对于输入的多个传感器数据，需要进行相应的预处理，如使用低通滤波器对加速度计的数据进行滤波，使用高通滤波器对陀螺仪的数据进行滤波。通过对算法的输出数据进行对比和分析，可以评估算法的精度、稳定性。同时，还
阅读更多2024-11-07
机器学习与成像技术：开启智能视觉的新篇章
1. 机器学习机器学习是人工智能的一个分支，它让计算机能够通过数据学习和改进，而无需进行明确的编程。机器学习的核心在于算法，这些算法能够从输入的数据中自动提取特征，并通过训练过程学习如何做出预测或决策
阅读更多2024-11-07
Pytest自动化测试框架详解
Pytest是一种基于Python编程语言的自动化测试框架，它提供了丰富的功能和灵活的扩展性，可以用于单元测试、集成测试、功能测试、端到端测试等多种场景。本文将介绍Pytest框架的基础知识，包括安装
阅读更多2024-11-07
Nature Methods | 基于流形约束的RNA速度推断精准解析细胞周期动态调节规律
这项研究介绍了一种新颖的RNA速度模型——VeloCycle，该模型基于流形约束的统计推断方法，旨在提高单细胞RNA测序数据中细胞周期速度变化的解析精度。与传统依赖启发式算法的RNA速度分析方法相比，
阅读更多2024-11-07
ATom：来自中央大学高分辨率气溶胶质谱仪（HR-AMS）的 L2 测量数据
该数据集提供了在美国国家航空航天局 ATom 任务飞行期间由高分辨率气溶胶质谱仪（HR-AMS）测量到的无机和有机物分离离子在大气中的浓度。所有四次 ATom 飞行任务的数据均已提供。HR-AMS 通
阅读更多2024-11-07
加入广告联盟有什么条件吗？
以一些知名的新闻资讯网站为例，它们凭借清晰的页面布局、丰富且有价值的内容，吸引了大量用户，从而满足了广告联盟对于网站质量的严格要求。与此同时，发布商还需要综合考虑广告联盟的信誉、支付方式、分成比例、服
阅读更多2024-11-07
JavaScript中，split() 的用法
在JavaScript中，split()方法是字符串对象的一个非常有用的方法，它允许你将一个字符串分割成多个子字符串，并将这些子字符串存储在一个数组中。这个方法通常用于处理包含分隔符（如逗号、空格、换
阅读更多2024-11-07
初学Java基础Day22---枚举
经验：一个类有固定几个对象，就用枚举代替。
阅读更多2024-11-07
简单记录某云创建云主机部署docker，能ping通外网而curl不通的问题
创建在Vxlan网络下的云主机部署docker后，启动docker服务后发现容器里可以解析ping通域名，curl访问却无法返回。
阅读更多2024-11-07
rabbitMQ RabbitTemplate 发送消息
当消息转发失败后就会触发ReturrnsCallback，会将消息返回给生产者，同时会返回与消息转发失败的相关信息（包含在参数returned内），可对此采取后续处理。消息发送确认机制：消息由prod
阅读更多2024-11-07

Android笔记(三十五)：用责任链模式封装一个App首页Dialog管理工具

背景

效果

原理分析

Demo验证

相关文章