2021-11-09 1.更新

JLChen

2021-11-09 c584c193d5dd4290bcbeddd434e1d642db59eb13

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package com.hdl.sdk.common.event; 
 
import androidx.annotation.NonNull; 
import androidx.collection.ArrayMap; 
 
 
import com.hdl.sdk.common.utils.ThreadToolUtils; 
 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Objects; 
import java.util.concurrent.ExecutorService; 
 
 
/** 
 * Created by Tong on 2021/9/22. 
 * 事件分发 
 */ 
public class EventDispatcher { 
 
    private static final ArrayMap<Object, List<EventListener>> EVENT = new ArrayMap<>(); 
 
    private static final ArrayMap<EventListener, Integer> TYPE = new ArrayMap<>(); 
 
    private static final int MAIN_TYPE = 0; 
    private static final int IO_TYPE = 1; 
 
    private static final ExecutorService ioThread = ThreadToolUtils.getInstance().newFixedThreadPool(2); 
 
    private EventDispatcher() { 
    } 
 
    private static class SingletonInstance { 
        private static final EventDispatcher INSTANCE = new EventDispatcher(); 
    } 
 
    public static EventDispatcher getInstance() { 
        return SingletonInstance.INSTANCE; 
    } 
 
    public synchronized void register(Object tag, EventListener listener) { 
        if (!EVENT.containsKey(tag)) { 
            EVENT.put(tag, new ArrayList<>()); 
        } 
        List<EventListener> events = EVENT.get(tag); 
        if (events != null && !events.contains(listener)) { 
            events.add(listener); 
        } 
        TYPE.put(listener, MAIN_TYPE); 
    } 
 
    public synchronized void registerIo(Object tag, EventListener listener) { 
        if (!EVENT.containsKey(tag)) { 
            EVENT.put(tag, new ArrayList<>()); 
        } 
        List<EventListener> events = EVENT.get(tag); 
        if (events != null && !events.contains(listener)) { 
            events.add(listener); 
        } 
        TYPE.put(listener, IO_TYPE); 
    } 
 
    public synchronized void remove(Object tag) { 
        ioThread.execute(new Runnable() { 
            @Override 
            public void run() { 
                try { 
                    if (EVENT.containsKey(tag)) { 
                        List<EventListener> list = EVENT.get(tag); 
                        for (EventListener eventListener : list) { 
                            TYPE.remove(eventListener); 
                        } 
                        EVENT.remove(tag); 
                    } 
                } catch (Exception ignored) { 
 
                } 
 
            } 
        }); 
    } 
 
    public synchronized void remove(Object tag, EventListener listener) { 
        ioThread.execute(new Runnable() { 
            @Override 
            public void run() { 
                try { 
                    if (EVENT.containsKey(tag)) { 
                        List<EventListener> ev = EVENT.get(tag); 
                        if (ev != null && !ev.isEmpty()) { 
                            TYPE.remove(listener); 
                            ev.remove(listener); 
                        } 
                    } 
                } catch (Exception ignored) { 
 
                } 
 
            } 
        }); 
    } 
 
    public synchronized void post(Object tag, @NonNull Object o) { 
        if (EVENT.containsKey(tag)) { 
            List<EventListener> list = EVENT.get(tag); 
            if (list != null && !list.isEmpty()) { 
                for (EventListener listener : list) { 
                    ThreadToolUtils.getInstance().runOnUiThread(new Runnable() { 
                        @Override 
                        public void run() { 
                            if (listener != null) { 
                                listener.onMessage(o); 
                            } 
                        } 
                    }); 
                } 
            } 
        } 
    } 
 
    public synchronized void clear() { 
        EVENT.clear(); 
        TYPE.clear(); 
    } 
 
    public synchronized void release() { 
        clear(); 
        ioThread.shutdownNow(); 
    } 
 
 
}