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;

/**

• Created by zhenglin.zhu on 2020/5/11.
  */
  public class LiveDataBus {
  private final Map<String, BusMutableLiveData> 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<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 extends MutableLiveData {

   private Map<Observer, Observer> observerMap = new HashMap<>();
  
   @Override
   public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
       super.observe(owner, observer);
       try {
           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 {
       //get wrapper's version
       Class<LiveData> 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);
   }
  

  }
  }