1稿饰、OKLiveDataBus簡(jiǎn)介
LiveDataBus是一個(gè)基于LiveData的事件總線庫(kù)憨奸，它可以幫助開發(fā)者在組件之間傳遞消息和事件褥民。
以下是LiveDataBus的簡(jiǎn)單總結(jié)：
- 1恬惯、LiveDataBus是基于LiveData的事件總線庫(kù)誉尖，它可以幫助開發(fā)者在組件之間傳遞消息和事件狭郑。
- 2腹暖、LiveDataBus使用單例模式，確保只有一個(gè)實(shí)例存在翰萨。
- 3脏答、LiveDataBus使用HashMap來(lái)存儲(chǔ)LiveData對(duì)象，每個(gè)LiveData對(duì)象對(duì)應(yīng)一個(gè)事件類型。
- 4殖告、LiveDataBus提供了注冊(cè)阿蝶、注銷、發(fā)送事件等方法黄绩，開發(fā)者可以根據(jù)需要使用羡洁。
- 5、LiveDataBus支持粘性事件爽丹，即在發(fā)送事件后筑煮，如果有訂閱者注冊(cè)，它們也可以收到該事件粤蝎。
- 6咆瘟、LiveDataBus支持線程切換，開發(fā)者可以指定事件在哪個(gè)線程中執(zhí)行诽里。
- 7袒餐、LiveDataBus使用了觀察者模式，當(dāng)事件發(fā)生時(shí)谤狡，所有訂閱者都會(huì)收到通知灸眼。
- 8、LiveDataBus是一個(gè)輕量級(jí)的庫(kù)墓懂，易于使用和集成焰宣。
總之，LiveDataBus是一個(gè)非常實(shí)用的事件總線庫(kù)捕仔，可以幫助開發(fā)者在Android應(yīng)用中實(shí)現(xiàn)組件之間的通信匕积。
2、Kotlin版本的OKLiveDataBus
/**
* Kotlin版本訂閱觀察者
*/
OKLiveDataBusKT.with("data1", String::class.java).observe(this) {
Log.d("lyy", "MainActivity2--Kotlin版本的 觀察者:${it}")
}
/**
* 調(diào)用Kotlin版本的OKLiveDataBus榜跌，發(fā)送消息
*/
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 使用
*
* //發(fā)送消息
* LiveDataBus.get().with("luo", String::class.java)
* .postValue("我是來(lái)自加入書架")
*
* //訂閱消息
* 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 {
// 設(shè)置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對(duì)象
Class<LiveData> classLiveData = LiveData.class;
// 獲取 LiveData類的mObservers對(duì)象 （Map對(duì)象）的 Field對(duì)象
Field fieldObservers = classLiveData.getDeclaredField("mObservers");
// 將mObservers 的private設(shè)置為 public
fieldObservers.setAccessible(true);
// 獲取當(dāng)前l(fā)ivedata的mObservers對(duì)象(map)
Object objectObservers = fieldObservers.get(this);
// 拿到mObservers（map）的class對(duì)象
Class<?> classObservers = objectObservers.getClass();
// 通過map的class對(duì)象拿到get（）的method對(duì)象
Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
methodGet.setAccessible(true);
// 通過map 的 get Method對(duì)象 拿到值 （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對(duì)象
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);
}
}
}
