1、OKLiveDataBus简介
LiveDataBus是一个基于LiveData的事件总线库，它可以帮助开发者在组件之间传递消息和事件。
以下是LiveDataBus的简单总结：
- 1、LiveDataBus是基于LiveData的事件总线库，它可以帮助开发者在组件之间传递消息和事件。
- 2、LiveDataBus使用单例模式，确保只有一个实例存在。
- 3、LiveDataBus使用HashMap来存储LiveData对象，每个LiveData对象对应一个事件类型。
- 4、LiveDataBus提供了注册、注销、发送事件等方法，开发者可以根据需要使用。
- 5、LiveDataBus支持粘性事件，即在发送事件后，如果有订阅者注册，它们也可以收到该事件。
- 6、LiveDataBus支持线程切换，开发者可以指定事件在哪个线程中执行。
- 7、LiveDataBus使用了观察者模式，当事件发生时，所有订阅者都会收到通知。
- 8、LiveDataBus是一个轻量级的库，易于使用和集成。
总之，LiveDataBus是一个非常实用的事件总线库，可以帮助开发者在Android应用中实现组件之间的通信。
2、Kotlin版本的OKLiveDataBus
/**
* Kotlin版本订阅观察者
*/
OKLiveDataBusKT.with("data1", String::class.java).observe(this) {
Log.d("lyy", "MainActivity2--Kotlin版本的 观察者:${it}")
}
/**
* 调用Kotlin版本的OKLiveDataBus，发送消息
*/
OKLiveDataBusKT.with("data1", String::class.java).postValue("666")
3、LiveDataBus.java
import androidx.annotation.NonNull;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import org.jetbrains.annotations.Nullable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
* LiveDataBus 使用
*
* //发送消息
* LiveDataBus.get().with("luo", String::class.java)
* .postValue("我是来自加入书架")
*
* //订阅消息
* LiveDataBus.get().with("luo").observe(this) {
* MyToash.Log("search", "--------------")
* }
*
*/
public class LiveDataBus {
private final Map<String, BusMutableLiveData<Object>> bus;
private LiveDataBus() {
bus = new HashMap<>();
}
private static class SingletonHolder {
private static final LiveDataBus DEFAULT_BUS = new LiveDataBus();
}
public static LiveDataBus get() {
return SingletonHolder.DEFAULT_BUS;
}
public <T> MutableLiveData<T> with(String key, Class<T> type) {
if (!bus.containsKey(key)) {
bus.put(key, new BusMutableLiveData<>());
}
return (MutableLiveData<T>) bus.get(key);
}
public MutableLiveData<Object> with(String key) {
return with(key, Object.class);
}
private static class ObserverWrapper<T> implements Observer<T> {
private Observer<T> observer;
public ObserverWrapper(Observer<T> observer) {
this.observer = observer;
}
@Override
public void onChanged(@Nullable T t) {
if (observer != null) {
if (isCallOnObserve()) {
return;
}
observer.onChanged(t);
}
}
private boolean isCallOnObserve() {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
if (stackTrace != null && stackTrace.length > 0) {
for (StackTraceElement element : stackTrace) {
if ("android.arch.lifecycle.LiveData".equals(element.getClassName()) &&
"observeForever".equals(element.getMethodName())) {
return true;
}
}
}
return false;
}
}
private static class BusMutableLiveData<T> extends MutableLiveData<T> {
private Map<Observer, Observer> observerMap = new HashMap<>();
@Override
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
super.observe(owner, observer);
try {
// 设置observer的version和LiveData一致
hook((Observer<T>) observer);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void observeForever(@NonNull Observer<? super T> observer) {
if (!observerMap.containsKey(observer)) {
observerMap.put(observer, new ObserverWrapper(observer));
}
super.observeForever(observerMap.get(observer));
}
@Override
public void removeObserver(@NonNull Observer<? super T> observer) {
Observer realObserver = null;
if (observerMap.containsKey(observer)) {
realObserver = observerMap.remove(observer);
} else {
realObserver = observer;
}
super.removeObserver(realObserver);
}
private void hook(@NonNull Observer<T> observer) throws Exception {
// 获取livedata的class对象
Class<LiveData> classLiveData = LiveData.class;
// 获取 LiveData类的mObservers对象 （Map对象）的 Field对象
Field fieldObservers = classLiveData.getDeclaredField("mObservers");
// 将mObservers 的private设置为 public
fieldObservers.setAccessible(true);
// 获取当前livedata的mObservers对象(map)
Object objectObservers = fieldObservers.get(this);
// 拿到mObservers（map）的class对象
Class<?> classObservers = objectObservers.getClass();
// 通过map的class对象拿到get（）的method对象
Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
methodGet.setAccessible(true);
// 通过map 的 get Method对象 拿到值 （Entry） （arg1：map ，arg2：key ）
Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);
// 拿到wrapper
Object objectWrapper = null;
if (objectWrapperEntry instanceof Map.Entry) {
objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();
}
if (objectWrapper == null) {
throw new NullPointerException("Wrapper can not be bull!");
}
// 反射wrapper对象
Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();
// 拿到wrapper的version
Field fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion");
fieldLastVersion.setAccessible(true);
//get livedata's version
Field fieldVersion = classLiveData.getDeclaredField("mVersion");
fieldVersion.setAccessible(true);
Object objectVersion = fieldVersion.get(this);
//set wrapper's version
fieldLastVersion.set(objectWrapper, objectVersion);
}
}
}
网友评论