观察者模式

问题：事件分发

思考：1、由于28之后，google限制反射使用，使用EventBus，怕哪一天就嗝屁了，所以事件分发不使用EventBus等来处理

          2、使用广播，想都不想，代码太复杂，看起来不舒服，哈哈哈

          3、循环存储Activity的栈内的ActivityList，将事件分发到每一个Activity，可行，但是每个Activity都得重写N多方法

解决：使用观察者模式解决问题

管理类：使用Map保存对象，事件复杂度为1

/**
 * 观察者管理类
 * <p>
 */
public class ObserverManager implements IBaseObservable {

    private static volatile ObserverManager INSTANCE;

    private Map<TypeObserverEnum, Set<IBaseObserver>> mMapObservers;

    private ObserverManager(Context context) {
        mMapObservers = new HashMap<>();
    }

    public static ObserverManager getInstance(Context context) {
        if (INSTANCE == null) {
            synchronized (ObserverManager.class) {
                if (INSTANCE == null) {
                    INSTANCE = new ObserverManager(context);
                }
            }
        }
        return INSTANCE;
    }

    /**
     * @param type
     * @param observer
     */
    @Override
    public void addObserver(TypeObserverEnum type, IBaseObserver observer) {
        if (mMapObservers != null) {
            /**
             * 首次
             */
            if (!mMapObservers.containsKey(type)) {
                mMapObservers.put(type, new HashSet<IBaseObserver>());
            }
            Set<IBaseObserver> baseObservers = mMapObservers.get(type);
            if (observer != null) {
                baseObservers.add(observer);
            }
        }
    }

    /**
     * @param type
     * @param observer
     */
    @Override
    public void removeObserver(TypeObserverEnum type, IBaseObserver observer) {
        if (mMapObservers != null) {
            /**
             * 首次
             */
            if (!mMapObservers.containsKey(type)) {
                return;
            }
            Set<IBaseObserver> observerSet = mMapObservers.get(type);
            if (observerSet.contains(observer)) {
                observerSet.remove(observer);
            }
        }
    }

    /**
     * @param type
     * @param obj
     */
    @Override
    public void notify(TypeObserverEnum type, Object obj) {
        if (mMapObservers != null) {
            /**
             * 首次
             */
            if (!mMapObservers.containsKey(type)) {
                return;
            }
            Set<IBaseObserver> observerSet = mMapObservers.get(type);
            for (IBaseObserver observer : observerSet) {
                if (observer != null) {
                    observer.onUpdate(type, obj);
                }
            }
        }
    }


}

IBaseObserver：

/**
 * 状态同步观察者
 */
public interface IBaseObserver {

    void onUpdate(TypeObserverEnum type, Object obj);

}

 

/**
 * 状态同步被观察者
 */
public interface IBaseObservable {

    /**
     * 添加观察者
     *
     * @param observer
     */
    void addObserver(TypeObserverEnum type, IBaseObserver observer);

    /**
     * 删除观察者
     *
     * @param observer
     */
    void removeObserver(TypeObserverEnum type, IBaseObserver observer);

    /**
     * 对应业务操作
     *
     * @param type
     * @param obj
     */
    void notify(TypeObserverEnum type, Object obj);

}

枚举，放入自定义的值 

/**
 * 业务类code
 */
public enum TypeObserverEnum {

    ON_AUDIO_PLAYER_ACTION, // 音频相关业务


}

 使用：（this：当前activity实现了IBaseObserver 接口，重写OnUpdate方法.

              MaterialContentBean:项目用到的实体类，可写随意实体）

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ObserverManager.getInstance(getContext()).addObserver(ON_AUDIO_PLAYER_ACTION,this);
}

@Override
public void onDestroy() {
    super.onDestroy();
    ObserverManager.getInstance(getContext()).removeObserver(ON_AUDIO_PLAYER_ACTION,this);
    LocalBroadcastManager.getInstance(getContext()).unregisterReceiver(broadcastReceiver);
}

@Override
public void onUpdate(TypeObserverEnum type, Object obj) {
    LogUtils.e("onUpdate: " + "---");
    switch (type) {
        case ON_AUDIO_PLAYER_ACTION:
            if (obj instanceof MaterialContentBean) {
                ...
            }
            break;
    }
}