2021-10-29

加粗样式
package com.zzl.solibrarycreate;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;

public class LiveDataBus {
private final Map 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 MutableLiveData with(String key, Class type) {
if (!bus.containsKey(key)) {
bus.put(key, new BusMutableLiveData<>());
}
return (MutableLiveData) bus.get(key);
}

public MutableLiveData with(String key) {
return with(key, Object.class);
}

private static class ObserverWrapper implements Observer {

 private Observer observer;

 public ObserverWrapper(Observer 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 extends MutableLiveData {

 private Map observerMap = new HashMap<>();

 @Override
 public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
     super.observe(owner, observer);
     try {
         hook((Observer) observer);
     } catch (Exception e) {
         e.printStackTrace();
     }
 }

 @Override
 public void observeForever(@NonNull Observer observer) {
     if (!observerMap.containsKey(observer)) {
         observerMap.put(observer, new ObserverWrapper(observer));
     }
     super.observeForever(observerMap.get(observer));
 }

 @Override
 public void removeObserver(@NonNull Observer observer) {
     Observer realObserver = null;
     if (observerMap.containsKey(observer)) {
         realObserver = observerMap.remove(observer);
     } else {
         realObserver = observer;
     }
     super.removeObserver(realObserver);
 }

 private void hook(@NonNull Observer observer) throws Exception {
     //get wrapper's version
     Class classLiveData = LiveData.class;
     Field fieldObservers = classLiveData.getDeclaredField("mObservers");
     fieldObservers.setAccessible(true);
     Object objectObservers = fieldObservers.get(this);
     Class classObservers = objectObservers.getClass();
     Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
     methodGet.setAccessible(true);
     Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);
     Object objectWrapper = null;
     if (objectWrapperEntry instanceof Map.Entry) {
         objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();
     }
     if (objectWrapper == null) {
         throw new NullPointerException("Wrapper can not be bull!");
     }
     Class classObserverWrapper = objectWrapper.getClass().getSuperclass();
     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);
 }

}
}