Android LiveDataBus报错：IllegalArg

1、产生的背景：

我的APP打开之后，点击Home，进入后台，过了大概5分钟，重新打开应用，发现应用会重启，然后就会报错：IllegalArgumentException: Cannot add the same observer with different lifecycles（注意：第一次打开APP不会报错，只有重启的时候报错）。

activity?.let {
    LiveDataBus.get().with(LiveDataBusConstant.LIVEDATA_POST_SECONDARY_DISCOUNT).observe(it) { item ->
                if ("saveSuccess" == item){
                    if (isColdStart){
                        isColdStart = false
                        isVisibleDiscountInfo()
                    }
                }

            }

            //支付成功消失
            LiveDataBus.get().with(LiveDataBusConstant.LIVEDATA_LOGIN_SUCCESS).observe(it) { item ->
                if ("paySuccess" == item){
                    if (RechargeDiscountDialog.secondaryDiscountDialog!=null){
                        RechargeDiscountDialog.secondaryDiscountDialog?.dismiss()
                    }
                }

            }
        }

2、解决：

再添加观察者之前，先移除上次添加的观察者即可。

  activity?.let {
            //先移除上次的观察者
            LiveDataBus.get().removekey(LiveDataBusConstant.LIVEDATA_LOGIN_SUCCESS)
            LiveDataBus.get().removekey(LiveDataBusConstant.LIVEDATA_POST_SECONDARY_DISCOUNT)

            //保存
            LiveDataBus.get().with(LiveDataBusConstant.LIVEDATA_POST_SECONDARY_DISCOUNT).observe(it) { item ->
                if ("saveSuccess" == item){
                    if (isColdStart){
                        isColdStart = false
                        isVisibleDiscountInfo()
                    }
                }

            }

            //支付成功消失
            LiveDataBus.get().with(LiveDataBusConstant.LIVEDATA_LOGIN_SUCCESS).observe(it) { item ->
                if ("paySuccess" == item){
                    if (RechargeDiscountDialog.secondaryDiscountDialog!=null){
                        RechargeDiscountDialog.secondaryDiscountDialog?.dismiss()
                    }
                }

            }
        }

移除的方法如下：

  /**
     * 首页重启时，同一个注册多个观察者，需要先调用这个方法，清除一下观察者，
     * 否则报错：IllegalArgumentException: Cannot add the same observer with different lifecycles
     * @param key
     */
    public void removekey(String key) {
        if (bus.containsKey(key)) {
            BusMutableLiveData<Object> objectBusMutableLiveData = bus.get(key);
            bus.remove(key);
            objectBusMutableLiveData = null;
        }
    }

3、完成的代码：

package com.youjiakeji.yjkjreader.kotlin.utils;


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", "--------------")
 * }
 * //删除上次的观察者
 * LiveDataBus.get().removekey(LiveDataBusConstant.LIVEDATA_LOGIN_SUCCESS)
 */
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);
    }

    /**
     * 首页重启时，同一个注册多个观察者，需要先调用这个方法，清除一下观察者，
     * 否则报错：IllegalArgumentException: Cannot add the same observer with different lifecycles
     * @param key
     */
    public void removekey(String key) {
        if (bus.containsKey(key)) {
            BusMutableLiveData<Object> objectBusMutableLiveData = bus.get(key);
            bus.remove(key);
            objectBusMutableLiveData = null;
        }
    }
    
    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);
        }
    }
}