完成时间分发库的编写，测试正常

endian11

2020-01-02 2268d28bb43c2b3d7b4dfd96d35c0a844390c5bd

完成时间分发库的编写，测试正常

 app/src/main/java/safeluck/drive/evaluation/cEventCenter/CEventCenter.java

New file
@@ -0,0 +1,202 @@
package safeluck.drive.evaluation.cEventCenter;

import android.text.TextUtils;
import android.util.Log;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

/**
 * MyApplication2
 * Created by lzw on 2020/1/2. 14:03:04
 * 邮箱：632393724@qq.com
 * All Rights Saved! Chongqing AnYun Tech co. LTD
 */
public class CEventCenter {

    private static final String TAG = CEventCenter.class.getSimpleName();

    /**
     * 监听器列表，支持一对多存储
     */
    private static final HashMap<String , Object> LISTENER_MAP = new HashMap<>();

    /**
     * 监听器列表锁
     */
    private static final Object LISTENER_LOCK = new Object();

    /**
     * 事件对象池
     */
    private static final CEventObjPool POOL = new CEventObjPool(5);

    /**
     * 注册/注销监听器
     * @param toBind true注册  false注销
     * @param listener 监听器
     * @param topic 单个主题
     */
    public static void onBindEvent(boolean toBind,ICEventListener listener,String topic){
        onBindEvent(toBind,listener,new String[]{topic});
    }

    /**
     *
     * @param toBind
     * @param listener
     * @param topics 多个主题
     */
    public static void onBindEvent(boolean toBind,ICEventListener listener,String[] topics){
        if (toBind){
            registerEventListener(listener, topics);
        }else{
            unregisterEventListener(listener, topics);
        }
    }

    /**
     * 注册监听器
     * @param listener
     * @param topic 单个主题
     */
    public static void registerEventListener(ICEventListener listener, String topic){
        registerEventListener(listener,new String[]{topic});
    }

    /**
     * 注销监听器
     * @param listener
     * @param topic  单个个主题
     */
    private static void unregisterEventListener(ICEventListener listener, String topic) {
        unregisterEventListener(listener,new String[]{topic});
    }

    /**
     * 注销监听器
     * @param listener
     * @param topics 多个主题
     */
    private static void unregisterEventListener(ICEventListener listener, String[] topics) {
        if (null == listener || null == topics){
            return;
        }
        synchronized (LISTENER_LOCK){
            for (String topic :
                    topics) {
                if (TextUtils.isEmpty(topic)) {
                    continue;
                }
                Object obj = LISTENER_MAP.get(topic);
                if (null == obj){
                    continue;
                }else if (obj instanceof ICEventListener){
                    //有一个监听器
                    if (obj == listener){
                        LISTENER_MAP.remove(topic);
                    }
                }else if (obj instanceof List){
                    //有多个监听器
                    LinkedList<ICEventListener> listeners = (LinkedList<ICEventListener>)obj;
                    listeners.remove(listener);
                }
            }
        }
    }
    /**
     * 注册监听器
     * @param listener
     * @param topics 多个主题
     */
    private static void registerEventListener(ICEventListener listener, String[] topics) {
        if (null == listener || null == topics){
            return;
        }
        synchronized (LISTENER_LOCK){
            for (String topic :
                    topics) {
                if (TextUtils.isEmpty(topic)){
                    continue;
                }
                Object obj = LISTENER_MAP.get(topic);
                if (null == obj){
                    //还没有监听器，直接放到Map集合
                    LISTENER_MAP.put(topic,listener);
                }else if (obj instanceof  ICEventListener){
                    //有一个监听器
                    ICEventListener oldListener = (ICEventListener)obj;
                    if (listener == oldListener){
                        //去重
                        continue;
                    }

                    LinkedList<ICEventListener> list = new LinkedList<>();
                    list.add(oldListener);
                    list.add(listener);
                    LISTENER_MAP.put(topic,list);
                }else if (obj instanceof List){
                    //有多个监听器
                    LinkedList<ICEventListener> listeners = (LinkedList<ICEventListener>)obj;
                    if (listeners.indexOf(listener) >=0){
                        //去重
                        continue;
                    }
                    listeners.add(listener);
                }
            }
        }
    }

    public static void dispatchEvent(String topic, int msgCode, int resultCode, Object object){
        if (!TextUtils.isEmpty(topic)){
            CEvent event = POOL.get();
            event.setMsgCode(msgCode);
            event.setTopic(topic);
            event.setResultCode(resultCode);
            event.setObj(object);

            dispatchEvent(event);
        }
    }

    private static void dispatchEvent(CEvent event){
        if (LISTENER_MAP.size() == 0){
            return;
        }
        if (null != event && !TextUtils.isEmpty(event.getTopic())){
            String topic = event.getTopic();

            //通知事件监听器处理事件
            ICEventListener listener = null;
            LinkedList<ICEventListener> listeners = null;
            synchronized (LISTENER_LOCK){
                Log.d(TAG, "dispatchEvent | topic="+topic+"\tmsgCode="+event.getMsgCode()+"\tresultCode="+event.getResultCode()
                +"\tobj="+event.getObj());
                Object obj = LISTENER_MAP.get(topic);
                if (obj == null){
                    return;
                }
                if (obj instanceof ICEventListener){
                    listener = (ICEventListener)obj;
                }else if (obj instanceof List){
                    listeners = (LinkedList<ICEventListener>)((LinkedList)obj).clone();
                }
            }

            if (null != listener){
                listener.onCEvent(topic,event.getMsgCode(),event.getResultCode(),event.getObj());
            }else if (null != listeners && listeners.size()>0){
                for (ICEventListener
                     l:
                     listeners) {
                    l.onCEvent(topic, event.getMsgCode(), event.getResultCode(), event.getObj());
                }
            }
            //把对象放回池里
            POOL.returnObj(event);
        }
    }

}

 app/src/main/java/safeluck/drive/evaluation/cEventCenter/CEventObjPool.java

New file
@@ -0,0 +1,25 @@
package safeluck.drive.evaluation.cEventCenter;

/**
 * 事件对象池
 * MyApplication2
 * Created by lzw on 2020/1/2. 13:58:00
 * 邮箱：632393724@qq.com
 * All Rights Saved! Chongqing AnYun Tech co. LTD
 */
public class CEventObjPool extends ObjectPool<CEvent>{

    public CEventObjPool(int capacity) {
        super(capacity);
    }

    @Override
    protected CEvent[] createObjPool(int capacity) {
        return new CEvent[capacity];
    }

    @Override
    protected CEvent createNewObj() {
        return new CEvent();
    }
}

 app/src/main/java/safeluck/drive/evaluation/cEventCenter/ICEventListener.java

New file
@@ -0,0 +1,23 @@
package safeluck.drive.evaluation.cEventCenter;

/**
 * 事件监听器
 * MyApplication2
 * Created by lzw on 2020/1/2. 14:00:14
 * 邮箱：632393724@qq.com
 * All Rights Saved! Chongqing AnYun Tech co. LTD
 */
public interface  ICEventListener {

    /**
     * 事件回调函数
     *
     * 如果obj使用了对象池
     * 那么事件完成后，obj即自动会受到对象池，请不要再其他线程继续使用，否则可能会导致数据不正常
     * @param topic
     * @param msgCode
     * @param resultCode
     * @param obj
     */
    void onCEvent(String topic, int msgCode, int resultCode, Object obj);
}

 app/src/main/java/safeluck/drive/evaluation/cEventCenter/ObjectPool.java

@@ -8,12 +8,20 @@
 * All Rights Saved! Chongqing AnYun Tech co. LTD
 */
public abstract class ObjectPool<T extends PooledObject> {
    /**
     *  对象容器
     */
    private T[] mContainer;

    private T[] mContainer;//对象容器
    /**
     *  对象锁
     */
    private final Object LOCK = new Object();

    private final Object LOCK = new Object();//对象锁

    private int length;//每次返回对象都放到数据末端，length表示前面可用对象数
    /***
     * 每次返回对象都放到数据末端，length表示前面可用对象数
     */
    private int length;

    public ObjectPool(int capacity) {
        mContainer = createObjPool(capacity);
@@ -60,4 +68,18 @@
        }
        return obj;
    }

    /**
     * 把对象放回池里面
     * @param obj
     */
    public final void returnObj(T obj){
        synchronized (LOCK){
            int size = mContainer.length;
            if (length < size){
                mContainer[length] = obj;
                length++;
            }
        }
    }
}