LiveEventBus

1.介绍

LiveEventBus 的源码地址：
https://github.com/JeremyLiao/LiveEventBus.git

LiveEventBus 一款Android消息总线，基于LiveData，具有生命周期感知能力，支持Sticky，支持AndroidX，支持跨进程，不支持线程分发

2.使用

    implementation 'io.github.jeremyliao:live-event-bus-x:1.8.0'

2.1.订阅消息

以生命周期感知模式订阅消息

LiveEventBus
    .get("some_key", String.class)
    .observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
        }
    });

以Forever模式订阅消息

LiveEventBus
    .get("some_key", String.class)
    .observeForever(observer);

2.2.发送消息

不定义消息直接发送

LiveEventBus
    .get("some_key")
    .post(some_value);

先定义消息，再发送消息

//定义类型
public class DemoEvent implements LiveEvent {
    public final String content;

    public DemoEvent(String content) {
        this.content = content;
    }
}
//发送消息
LiveEventBus
        .get(DemoEvent.class)
        .post(new DemoEvent("Hello world"));

2.3.初始化

配置在 Application 中：

  LiveEventBus
             .config()
             .autoClear(true)
             .lifecycleObserverAlwaysActive(true);

详细：

• lifecycleObserverAlwaysActive

配置LifecycleObserver（如Activity）接收消息的模式（默认值true）：

true：整个生命周期（从onCreate到onDestroy）都可以实时收到消息

false：激活状态（Started）可以实时收到消息，非激活状态（Stoped）无法实时收到消息，需等到Activity重新变成激活状态，方可收到消息

• autoClear
  配置在没有Observer关联的时候是否自动清除LiveEvent以释放内存（默认值false）

• setJsonConverter
  配置JsonConverter（默认使用gson）

• setLogger
  配置Logger（默认使用DefaultLogger）

• enableLogger
  配置是否打印日志（默认打印日志）

• setContext
  如果广播模式有问题，请手动传入Context，需要在application onCreate中配置

3.详细文档

3.1.获取Observable

public final class LiveEventBus {

    /**
     * 通过Key获取
     * get observable by key with type
     *
     * @param key String
     * @param type Class
     * @param <T> T
     * @return Observable
     */
    public static <T> Observable<T> get(@NonNull String key, @NonNull Class<T> type) {
        return LiveEventBusCore.get().with(key, type);
    }

    /**
     * 通过Key获取
     * get observable by key
     *
     * @param key String
     * @param <T> T
     * @return Observable
     */
    public static <T> Observable<T> get(@NonNull String key) {
        return (Observable<T>)get(key, Object.class);
    }

    /**
     * 通过eventType获取
     * get observable from eventType
     *
     * @param eventType Class
     * @param <T> T
     * @return Observable
     */
    public static <T extends LiveEvent> Observable<T> get(@NonNull Class<T> eventType) {
        return get(eventType.getName(), eventType);
    }

3.2.消息发送

public interface Observable<T> {

    /**
     * 进程内发送消息
     *
     * @param value 发送的消息
     */
    void post(T value);

    /**
     * App内发送消息，跨进程使用
     *
     * @param value 发送的消息
     */
    void postAcrossProcess(T value);

    /**
     * App之间发送消息
     *
     * @param value 发送的消息
     */
    void postAcrossApp(T value);

    /**
     * 进程内发送消息，延迟发送
     *
     * @param value 发送的消息
     * @param delay 延迟毫秒数
     */
    void postDelay(T value, long delay);

    /**
     * 进程内发送消息，延迟发送，带生命周期
     * 如果延时发送消息的时候sender处于非激活状态，消息取消发送
     *
     * @param sender 消息发送者
     * @param value  发送的消息
     * @param delay  延迟毫秒数
     */
    void postDelay(LifecycleOwner sender, T value, long delay);

    /**
     * 进程内发送消息
     * 强制接收到消息的顺序和发送顺序一致
     *
     * @param value 发送的消息
     */
    void postOrderly(T value);

    /**
     * 以广播的形式发送一个消息
     * 需要跨进程、跨APP发送消息的时候调用该方法
     * 可使用postAcrossProcess or postAcrossApp代替
     *
     * @param value 发送的消息
     */
    @Deprecated
    void broadcast(T value);

    /**
     * 以广播的形式发送一个消息
     * 需要跨进程、跨APP发送消息的时候调用该方法
     *
     * @param value      发送的消息
     * @param foreground true:前台广播、false:后台广播
     * @param onlyInApp  true:只在APP内有效、false:全局有效
     */
    void broadcast(T value, boolean foreground, boolean onlyInApp);

3.3.消息接收

    /**
     * 注册一个Observer，生命周期感知，自动取消订阅
     *
     * @param owner    LifecycleOwner
     * @param observer 观察者
     */
    void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer);

    /**
     * 注册一个Observer，生命周期感知，自动取消订阅
     * 如果之前有消息发送，可以在注册时收到消息（消息同步）
     *
     * @param owner    LifecycleOwner
     * @param observer 观察者
     */
    void observeSticky(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer);

    /**
     * 注册一个Observer，需手动解除绑定
     *
     * @param observer 观察者
     */
    void observeForever(@NonNull Observer<T> observer);

    /**
     * 注册一个Observer，需手动解除绑定
     * 如果之前有消息发送，可以在注册时收到消息（消息同步）
     *
     * @param observer 观察者
     */
    void observeStickyForever(@NonNull Observer<T> observer);

    /**
     * 通过observeForever或observeStickyForever注册的，需要调用该方法取消订阅
     *
     * @param observer 观察者
     */
    void removeObserver(@NonNull Observer<T> observer);

3.4.跨进程消息类型

• 支持对基本数据类型消息的跨进程发送
  int
  float
  long
  boolean
  double
  String

• 支持Serializable和Parcelable类型消息的跨进程发送
  提供SerializableProcessor
  提供ParcelableProcessor

• 支持Bean类型消息的跨进程发送
  提供GsonProcessor以Gson方式提供支持
  需要用注解@IpcConfig指定GsonProcessor：

@IpcConfig(processor = GsonProcessor.class)

• 支持自定义扩展
  实现自定义Processor，实现Processor接口
  用注解@IpcConfig指定自定义Processor

3.5.混淆

-dontwarn com.jeremyliao.liveeventbus.**
-keep class com.jeremyliao.liveeventbus.** { *; }
-keep class androidx.lifecycle.** { *; }
-keep class androidx.arch.core.** { *; }

参考地址

转自：
LiveEventBus的使用
作者：因为我的心
链接： https://www.jianshu.com/p/6df10c681f78
来源：简书