ViewHolder 的 MVVM实现

(1)使BaseLifecycleViewHolder实现LifecycleOwner接口：

private var mLifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this@BaseLifeCycleViewHolder)  
    override fun getLifecycle(): Lifecycle {  
        return mLifecycleRegistry  
    } 

(2)为BaseLifecycleViewHolder添加生命周期：

我们认为ViewHolder在创建和被复用的时候应该算作一个新的生命周期的开始，而这两个时机都会走到onBindViewHolder()，所以我们在onBindViewHolder()中注册onCreate和onStart事件。

onStop和onDestroy在itemView的onViewDetachedFromWindow()中注册。但是由于itemView从window中detach后，有可能只是从屏幕中移除但并没有被真正回收，下次滑动移回来将不会走onBindViewHolder()，而是直接走onViewAttachedToWindow()，所以在onViewAttachedToWindow()将会判断ViewHolder的state，如果不处于Start状态，onCreate和onStart会在此时注册。BaseLifeCycleViewHolder的生命周期如下图所示：

代码如下所示：

BaseLifeCycleAdapter：

@Override  
    public void onBindViewHolder(@NonNull VH holder, int position) {  
        holder.registerLifecycle(true);  
        super.onBindViewHolder(holder, position);  
    } 

BaseLifeCycleViewHolder：

itemView.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {  
        override fun onViewDetachedFromWindow(v: View?) {  
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)  
            mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)  
        }  

        override fun onViewAttachedToWindow(v: View?) {  
            if (mLifecycleRegistry.currentState != Lifecycle.State.STARTED) {  
                registerLifecycle(false)  
            }  
        }  
    })

registerLifecycle():

fun registerLifecycle(resetVersion: Boolean) {  
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)  
        if (resetVersion) {  
            mViewHolderVersion++ //被复用后ViewHolder的version加1  
        }  
        val bindList = bindLiveData(ArrayList<Pair<VHLiveData<Any>, Observer<Any>>>())  
        bindList?.forEach {
            it.first?.bindLifecycleOwner(this, it.second!!, resetVersion)
        }
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)  
    }

其中bindLiveData()是个抽象方法，需要子类去实现，为list添加数据

abstract fun bindLiveData(list: ArrayList<Pair<VHLiveData<Any>, Observer<Any>>>): ArrayList<Pair<VHLiveData<Any>, Observer<Any>>>?  

(3) bindLiveData()的实现:

在registerLifecycle()方法中，我们提供了抽象方法bindLiveData()拿到LiveData与Observer，并调用VHLiveData的bindLifecycleOwner()方法进行绑定。在registerLifecycle()中有个bool型的resetVersion变量，这个变量的作用将在之后进行说明。bindLiveData()的实现如以下示例代码：

@org.jetbrains.annotations.Nullable  
    @Override  
    public ArrayList<Pair<VHLiveData<Object>, Observer<Object>>> bindLiveData(@NotNull ArrayList<Pair<VHLiveData<Object>, Observer<Object>>> list) {  
        list.add(new Pair(mViewModel.getMRoomStatus(), new Observer<Integer>() {  
            @Override  
            public void onChanged(@Nullable Integer status) {  
                setRoomText(status);  
            }  
        }));  
        return list;  
    } 

在介绍VHLiveData的实现之前，我们先对原生的LiveData源码进行解析，以便更好的理解改造的目的。我们从observe()方法开始：

@MainThread  
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {  
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {  
            // ignore  
            return;  
        }  
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);  
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);  
        if (existing != null && !existing.isAttachedTo(owner)) {  
            throw new IllegalArgumentException("Cannot add the same observer"  
                    + " with different lifecycles");  
        }  
        if (existing != null) {  
            return;  
        }  
        owner.getLifecycle().addObserver(wrapper);  
    } 

每一次observe()时会将LifecycleOwner和Observer对象封装成一个LifecycleBoundObserver()对象，并放入mObservers这个Map中：

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {  
        @NonNull final LifecycleOwner mOwner;  

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {  
            super(observer);  
            mOwner = owner;  
        }  

        @Override  
        boolean shouldBeActive() {  
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);  
        }  

        @Override  
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {  
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {  
                removeObserver(mObserver);  
                return;  
            }  
            activeStateChanged(shouldBeActive());  
        }  

        @Override  
        boolean isAttachedTo(LifecycleOwner owner) {  
            return mOwner == owner;  
        }  

        @Override  
        void detachObserver() {  
            mOwner.getLifecycle().removeObserver(this);  
        }  
    }

如果LifecycleOwner状态发生了变化，会执行activeStateChanged()：

void activeStateChanged(boolean newActive) {  
            if (newActive == mActive) {  
                return;  
            }  
            // immediately set active state, so we'd never dispatch anything to inactive  
            // owner  
            mActive = newActive;  
            boolean wasInactive = LiveData.this.mActiveCount == 0;  
            LiveData.this.mActiveCount += mActive ? 1 : -1;  
            if (wasInactive && mActive) {  
                onActive();  
            }  
            if (LiveData.this.mActiveCount == 0 && !mActive) {  
                onInactive();  
            }  
            if (mActive) {  
                dispatchingValue(this);  
            }  
        }  


    private void dispatchingValue(@Nullable ObserverWrapper initiator) {  
        if (mDispatchingValue) {  
            mDispatchInvalidated = true;  
            return;  
        }  
        mDispatchingValue = true;  
        do {  
            mDispatchInvalidated = false;  
            if (initiator != null) {  
                considerNotify(initiator);  
                initiator = null;  
            } else {  
                for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =  
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {  
                    considerNotify(iterator.next().getValue());  
                    if (mDispatchInvalidated) {  
                        break;  
                    }  
                }  
            }  
        } while (mDispatchInvalidated);  
        mDispatchingValue = false;  
    }  

    private void considerNotify(ObserverWrapper observer) {  
        if (!observer.mActive) {  
            return;  
        }  
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.  
        //  
        // we still first check observer.active to keep it as the entrance for events. So even if  
        // the observer moved to an active state, if we've not received that event, we better not  
        // notify for a more predictable notification order.  
        if (!observer.shouldBeActive()) {  
            observer.activeStateChanged(false);  
            return;  
        }  
        if (observer.mLastVersion >= mVersion) {  
            return;  
        }  
        observer.mLastVersion = mVersion;  
        //noinspection unchecked  
        observer.mObserver.onChanged((T) mData);  
} 

在considerNotify()中，有两个变量需要注意，LiveData持有的mVersion和LifecycleBoundObserver父类ObserverWrapper持有的mLastVersion，这两个变量的默认值都是-1，代码中会判断mLastVersion和mVersion的大小，如果mLastVersion小于mVersion就会走到onChanged()。这个mVersion是在setValue()中赋值的(postValue方法最后也会执行到setValue中)：

@MainThread  
    protected void setValue(T value) {  
        assertMainThread("setValue");  
        mVersion++;  
        mData = value;  
        dispatchingValue(null);  
    }

如果我们使用原生的LiveData，由于LiveData在ViewHolder复用后还是之前的LiveData对象，所以mVersion的值会根据LiveData之前的setValue的次数增加。mLastVersion的值是在初始化LifecycleBoundObserver()时，在其父类ObserverWrapper中会被赋值为-1，每次setValue后会将mVersion的值赋予mLastVersion。

在上面的代码中我们可知，每一次LiveData和Observer进行绑定时都会新创建一个LifecycleBoundObserver对象，mLastVersion的值为-1。这就导致在ViewHolder复用的时候，mLastVersion是-1，mVersion的值若>-1就会走到onChanged()中。从而导致复用问题。

因此VHLiveData增加了bindLifecycleOwner()方法，用来代替原生的observe()方法，考虑到修改mVersion的值可能会引起多个Observer与LiveData绑定时数据接收的隐患，我们决定在复用时修改mObservers中相应ObserverWrapper持有的mLastVersion变量。

通过反射从mObservers中拿到该Observer对应的LifecycleBoundObserver对象，再将mVersion的值赋予给其父类ObserverWrapper持有的mLastVersion。VHLiveData的代码如下：

public class VHLiveData<T> extends MutableLiveData<T> {  

        public void bindLifecycleOwner(@NonNull LifecycleOwner owner, @NonNull Observer observer, boolean resetVersion) {  
            super.observe(owner, observer);  
            if (resetVersion) {  
                try {  
                    Class hySuperClass = LiveData.class;  
                    Field observers = hySuperClass.getDeclaredField("mObservers");  
                    observers.setAccessible(true);  
                    Object objectObservers = observers.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) {  
                        Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();  
                        Field lastVersion = classObserverWrapper.getDeclaredField("mLastVersion");  
                        lastVersion.setAccessible(true);  

                        Field version = hySuperClass.getDeclaredField("mVersion");  
                        version.setAccessible(true);  
                        Object objectVersion = version.get(this); //set wrapper's version  
                        lastVersion.set(objectWrapper, objectVersion);  

                        LogUtil.d("bigcatduan1", "set mLastVersion: " + objectVersion);  
                    }  


                } catch (Exception e) {  
                    LogUtil.e("bigcatduan1", "set mLastVersion failed");  
                    e.printStackTrace();  
                }  
            }  
        }  

    }

以上方案使各个模块Owner可使用类似Activity或Fragment的方式实现ViewHolder的MVVM模式，并解决ViewHolder复用与异步数据绑定错乱的问题。但是目前我们无法通过ViewModel，实现类似LiveData在Activity和Fragment的数据共享功能，未来会慢慢补充。

参考资料:

[1]https://developer.android.google.cn/reference/androidx/lifecycle/LiveData.html?

[2] https://www.jianshu.com/p/d0ac108b7698

[3]https://www.jianshu.com/p/84f5c9ed0c59