Architecture Components之LiveData的扩展

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Hubert_bing/article/details/78771770

此文章同步发布了简书:http://www.jianshu.com/p/605d8d7e1d3f

最近研究了一下Architecture Components,尝试用这个架构写了一个小demo,发现了一些问题,也有了一些心得,想分享给大家。

以下关于LiveData的基础使用摘自:[译] Architecture Components 之 LiveData

LiveData

LiveData 是一个数据持有者类,它持有一个值并允许观察该值。不同于普通的可观察者,LiveData 遵守应用程序组件的生命周期,以便 Observer 可以指定一个其应该遵守的 Lifecycle。

LiveData主要方法

  • onActive()

LiveData 有一个处于活动状态的观察者时该方法被调用,这意味着需要开始从设备观察位置更新。

  • onInactive()

LiveData 没有任何处于活动状态的观察者时该方法被调用。由于没有观察者在监听,所以没有理由保持与 LocationManager 的连接。这是非常重要的,因为保持连接会显著消耗电量并且没有任何好处。

  • setValue()

调用该方法更新 LiveData 实例的值,并将此变更通知给处于活动状态的观察者。

可以通过addObserver添加数据的观察者来更新界面,展示新的数据。

  liveData.addObserver(this, location -> {
                    // 更新 UI
                });

请注意,addObserver() 方法将 LifecycleOwner 作为第一个参数传递(即Activity或者Fragment)。这样做表示该观察者应该绑定到 Lifecycle,意思是:

  • 如果 Lifecycle 不处于活动状态(STARTED 或 RESUMED),即使该值发生变化也不会调用观察者。

  • 如果 Lifecycle 被销毁,那么自动移除观察者。

LiveData 有以下优点:

  • 没有内存泄漏:因为 Observer 被绑定到它们自己的 Lifecycle 对象上,所以,当它们的 Lifecycle 被销毁时,它们能自动的被清理。

  • 不会因为 activity 停止而崩溃:如果 ObserverLifecycle 处于闲置状态(例如:activity 在后台时),它们不会收到变更事件。

  • 始终保持数据最新:如果 Lifecycle 重新启动(例如:activity 从后台返回到启动状态)将会收到最新的位置数据(除非还没有)。

  • 正确处理配置更改:如果 activity 或 fragment 由于配置更改(如:设备旋转)重新创建,将会立即收到最新的有效位置数据。

  • 资源共享:可以只保留一个 MyLocationListener 实例,只连接系统服务一次,并且能够正确的支持应用程序中的所有观察者。

  • 不再手动管理生命周期你可能已经注意到,fragment 只是在需要的时候观察数据,不用担心被停止或者在停止之后启动观察。由于 fragment 在观察数据时提供了其 Lifecycle,所以 LiveData 会自动管理这一切。

问题

看了以上的介绍,发现LiveData还是非常好用的,等同于以前用rxLifecycle来管理生命周期,但是在实际使用的时候就发现问题了,LiveData只能传递一个值,之前我们用Retrofit+OkHttp+rxJava等构建MVP模式的应用时,网络数据请求经常会有多种结果:(1)正常返回数据,(2)接口返回,错误结果(3)网络请求失败 (4)列表无更多数据(5)接口正常返回,无数据 。。。等等情况,之前我们会在Presenter层通过回调获得这些发生在Model层的情况,然后调用View层改变界面的方法展示给用户,但是使用LiveData时View层可以直接通过ViewModel获得Model提供的LiveData,有数据时可以正常显示,但是异常时就显得力不从心了,我们只能传递一个值:有值或者null,无法判断复杂的具体的情况。

final-architecture.png

上图是官方提供的Architecture Components架构示意图,其中的依赖关系应该是单向的(隐藏的观察、被观察的关系不算),即Activity/Fragment持有ViewModel的引用,ViewModel持有Repository,提供LiveData。。。官方也提到ViewModel仅仅是一个LiveData的容器,不应该持有Activity/Fragment的引用。

基于以上这种情况下如何根据不同的情况改变界面那?例如:弹出吐司,对话框,显示网络异常等等那???啰嗦了这么半天,终于引出今天的话题——扩展LiveData 以满足需求。

扩展

先来分析一下LiveData,当添加了观察者,一旦调用setValue方法,观察者的onChanged方法就会接受到新的值。传递的值是通过LiveData<T>泛型定义。
既然是要区分类型,一开始的思路是将泛型定义成自定义的ActionEntity<T>,有点类似网络接口返回,id区分类型,extra附带额外数据,original是原始的value数据,即将真实数据包装一层,通过id来区分不同的情况:

public class ActionEntity<T> {
    public static final int ACTION = 0x1;
    public static final int VALUE = 0x2;

    public int type;

    public int id;
    public Object[] extra;
    public T original;

    public ActionEntity(T original) {
        this.original = original;
        type = VALUE;
    }

    public ActionEntity(int id, Object[] extra) {
        this.id = id;
        this.extra = extra;
        type = ACTION;
    }
}

接下来就是修改LiveData的setValue方法实现自动装包,让使用时感知不到包装的存在

import android.arch.lifecycle.LifecycleOwner;
import android.arch.lifecycle.MediatorLiveData;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

/**
 * Created by hubert
 * <p>
 * Created on 2017/12/7.
 */

public class ActionLiveData2<T> extends MediatorLiveData<ActionEntity<T>> implements ActionCreator {

    @Override
    public void setAction(int id, Object... args) {
        super.setValue(new ActionEntity<T>(id, args));
    }

    public void setValue_(T value) {
        super.setValue(new ActionEntity<T>(value));
    }

    public void postValue_(T value) {
        super.postValue(new ActionEntity<T>(value));
    }

    public void observe_(@NonNull LifecycleOwner owner, @NonNull ActionObserver2<T> observer) {
        super.observe(owner, observer);
    }

    public void observeForever_(@NonNull ActionObserver2<T> observer) {
        super.observeForever(observer);
    }

    public void removeObserver_(@NonNull ActionObserver2<T> observer) {
        super.removeObserver(observer);
    }

    @Nullable
    public T getValue_() {
        ActionEntity<T> entity = super.getValue();
        return entity == null ? null : entity.original;
    }
}

修改Observer的onChanged方法实现自动拆包

import android.arch.lifecycle.Observer;
import android.support.annotation.Nullable;

/**
 * Created by hubert
 * <p>
 * Created on 2017/12/7.
 */

public abstract class ActionObserver2<T> implements Observer<ActionEntity<T>>, ActionHandler {

    @Override
    public final void onChanged(@Nullable ActionEntity<T> entity) {
        if (entity != null) {
            if (entity.type == ActionEntity.VALUE) {
                onChanged_(entity.original);
            } else {
                onAction(entity.id, entity.extra);
            }
        }
    }

    public abstract void onChanged_(T entity);
}

不知道你有没有注意到很多方法最后都有_,这是由于对T泛型的数据做了改变,新包装的方法无法使用原方法名,只能通过添加下划线来区别原方法。
这样修改的话直接使用的话是能达到我的目的,但是通常情况下LiveData会通过Transformations进行转换,这时候泛型将很难定义,而且无法申明我们定义的类,因为Transformations的switchMap方法返回的必须是LiveData<T>,泛型只能定义成LiveData<ActionEntity<T>>,虽然我的定义的ActionLiveData2<T>也是继承自LiveData<ActionEntity<T>>,但是并不相等啊!!!
于是自己都写不下去了�� 并且这样的命名也非常的让我不爽,于是废弃了这种方式。

接着我又有了一个想法��,直接让LiveData传递Action,就像传递Value一样地传递:通过setAction设置事件,并且在Observer中onAction方法中接受事件作出处理。这个可以有!仿照value是怎么传递的不就行了嘛!��
然后我仔细分析了LiveData的源码,了解了其中是如何传递Value的,但是其中处理value的方法基本都是private的,子类无法使用。因此,我只能按照同样的逻辑来实现Action的传递:


import android.arch.lifecycle.LifecycleOwner;
import android.arch.lifecycle.LiveData;
import android.arch.lifecycle.MediatorLiveData;
import android.arch.lifecycle.Observer;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.NonNull;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Created by hubert on 2017/12/6.
 * <p>
 */
public class ActionLiveData<T> extends MutableLiveData<T> implements ActionCreator {

    private Set<ActionObserver<T>> actionObservers = new HashSet<>();
    private boolean active;//父类中有这个属性,但是也是private

    private ActionEntity actionEntity;

    private Handler handler;
    private Runnable actionRun = new Runnable() {
        @Override
        public void run() {
            dispatchAction();
        }
    };

    private void dispatchAction() {
        if (active) {
            for (ActionObserver<T> actionObserver : actionObservers) {
                actionObserver.onAction(actionEntity.id, actionEntity.extra);
            }
        }
    }

    @Override
    protected void onActive() {
        super.onActive();
        active = true;
    }

    @Override
    protected void onInactive() {
        super.onInactive();
        active = false;
    }

    @Override
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        super.observe(owner, observer);
        if (observer instanceof ActionObserver) {
            actionObservers.add((ActionObserver<T>) observer);
        }
    }

    @Override
    public void removeObserver(@NonNull Observer<T> observer) {
        super.removeObserver(observer);
        if (observer instanceof ActionObserver) {
            actionObservers.remove(observer);
        }
    }

      /**
     * 设置事件
     * @param id 事件id
     * @param args 可选的参数
     */
    @Override
    public void setAction(int id, Object... args) {
        actionEntity = new ActionEntity(id, args);
        if (isMainThread()) {
            dispatchAction();
        } else {
            if (handler == null) {
                handler = new Handler(Looper.getMainLooper());
            }
            handler.post(actionRun);
        }
    }

    public boolean isMainThread() {
        return Thread.currentThread() == Looper.getMainLooper().getThread();
    }

Action相关接口的声明:

public interface ActionCreator {

    void setAction(int id, Object... args);
}

public interface ActionHandler {

    void onAction(int id, Object... args);
}

public interface ActionObserver<T> extends Observer<T>, ActionHandler {

}

使用时传入ActionObserver复写onAction(int id, Object… args)接收Action事件

actionLiveData.observe(this, new ActionObserver<Integer>() {
      @Override
       public void onAction(int id, Object... args) {
           if (id == 1) {
               //do something
           }
       }

      @Override
       public void onChanged(@Nullable Integer integer) {
           //the original value
       }
 });

完美!马上把demo中的LiveData换成ActionLiveData跑上~ 没有反应��,怎么可能,我的逻辑…应该完美!�� 各种断点找原因,到底为什么没有传递过来。。。

最终被我发现了!

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    private final MutableLiveData<String> addressInput = new MutableLiveData();
    public final LiveData<String> postalCode =
            Transformations.switchMap(addressInput, (address) -> {
                return repository.getPostCode(address);
             });

  public MyViewModel(PostalCodeRepository repository) {
      this.repository = repository
  }

  private void setInput(String address) {
      addressInput.setValue(address);
  }
}

我的LiveData是通过Transformations.switchMap进行转换,或者说传递,即让一个LiveData(view层中获得的那个,我们简称小v)观察另一个LiveData(M层生成的小m),请求数据只会改变小m的value,switchMap方法内部其实就是给小m设置一个Observer,当小m的value改变时会调用该Observer的onChanged方法,在该方法中调用小v的setValue,这样View层的Observer的onChanged方法就可以改变界面。
其中只处理了value的传递,并且返回的对象是方法内部new的这个final MediatorLiveData<Y> result = new MediatorLiveData<>();,我们自己新添加的action当然不会被传递啦。
��既然这样,那我们就自己传递吧。还是仿照MediatorLiveData中传递方式,新增一个ActionSource类:


/**
 * Created by hubert on 2017/12/6.
 * <p>
 * LiveData本身只能有一种泛型的数据,在(接口)数据返回时只能设置有值或者null来判断,
 * 无法传递其他信息,如需要提示网络,数据错误等情况,为每一种情况定义一个LiveData又太过于繁琐。
 * 基于以上考虑对LiveData进行扩展,使其支持传递自定义Action,
 * 通过调用{@code setAction(int id, Object... args)}发送事件。
 * 并在observe方法中传入{@link ActionObserver}用于接收action事件作出处理。
 * <pre>
 * actionLiveData.observe(this, new ActionObserver<Integer>() {
 *      {@literal @}Override
 *      public void onAction(int id, Object... args) {
 *          if (id == 1) {
 *              //do something
 *          }
 *      }
 *
 *      {@literal @}Override
 *      public void onChanged(@Nullable Integer integer) {
 *          //the original value
 *      }
 * });
 * </pre>
 */
public class ActionLiveData<T> extends MediatorLiveData<T> implements ActionCreator {

    private Set<ActionObserver<T>> actionObservers = new HashSet<>();
    private boolean active;

    private ActionEntity actionEntity;

    private Handler handler;
    private Runnable actionRun = new Runnable() {
        @Override
        public void run() {
            dispatchAction();
        }
    };

    /**
     * 通知Observer更新事件
     */
    private void dispatchAction() {
        if (active) {
            for (ActionObserver<T> actionObserver : actionObservers) {
                actionObserver.onAction(actionEntity.id, actionEntity.extra);
            }
        }
    }

    @Override
    protected void onActive() {
        super.onActive();
        active = true;
        for (Map.Entry<ActionLiveData<?>, ActionSource<?>> entry : mHandlers.entrySet()) {
            entry.getValue().plug();
        }
    }

    @Override
    protected void onInactive() {
        super.onInactive();
        active = false;
        for (Map.Entry<ActionLiveData<?>, ActionSource<?>> entry : mHandlers.entrySet()) {
            entry.getValue().unplug();
        }
    }

    @Override
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        super.observe(owner, observer);
        if (observer instanceof ActionObserver) {
            actionObservers.add((ActionObserver<T>) observer);
        }
    }

    @Override
    public void removeObserver(@NonNull Observer<T> observer) {
        super.removeObserver(observer);
        if (observer instanceof ActionObserver) {
            actionObservers.remove(observer);
        }
    }

    /**
     * 设置事件
     * @param id 事件id
     * @param args 可选的参数
     */
    @Override
    public void setAction(int id, Object... args) {
        actionEntity = new ActionEntity(id, args);
        if (isMainThread()) {
            dispatchAction();
        } else {
            if (handler == null) {
                handler = new Handler(Looper.getMainLooper());
            }
            handler.post(actionRun);
        }
    }

    public boolean isMainThread() {
        return Thread.currentThread() == Looper.getMainLooper().getThread();
    }

    /****支持Transformations的转换***/

    private Map<ActionLiveData<?>, ActionSource<?>> mHandlers = new HashMap<>();

    @Override
    public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<S> onChanged) {
        super.addSource(source, onChanged);
        if (source instanceof ActionLiveData && onChanged instanceof ActionObserver) {
            addActionObserver((ActionLiveData<S>) source, (ActionObserver<S>) onChanged);
        }
    }

    protected <S> void addActionObserver(ActionLiveData<S> source, ActionObserver<S> actionObserver) {
        ActionSource<S> actionSource = new ActionSource<>(source, actionObserver);
        ActionSource<?> existing = mHandlers.put(source, actionSource);
        if (existing != null) {
            return;
        }
        if (hasActiveObservers()) {
            actionSource.plug();
        }
    }

    @Override
    public <S> void removeSource(@NonNull LiveData<S> toRemote) {
        super.removeSource(toRemote);
        if (toRemote instanceof ActionLiveData) {
            removeActionSource(toRemote);
        }
    }

    protected <S> void removeActionSource(@NonNull LiveData<S> toRemote) {
        ActionSource<?> source = mHandlers.remove(toRemote);
        if (source != null) {
            source.unplug();
        }
    }

    public static class ActionSource<T> implements ActionHandler {

        ActionLiveData<T> actionLiveData;
        ActionObserver<T> actionObserver;

        public ActionSource(ActionLiveData<T> actionLiveData, ActionObserver<T> actionObserver) {
            this.actionLiveData = actionLiveData;
            this.actionObserver = actionObserver;
        }

        void plug() {
            actionLiveData.observeForever(actionObserver);
        }

        void unplug() {
            actionLiveData.removeObserver(actionObserver);
        }

        @Override
        public void onAction(int id, Object... args) {
            actionObserver.onAction(id, args);
        }
    }
}

定义ActionTransformations修改Transformations的逻辑,以实现action事件的传递:


import android.arch.core.util.Function;
import android.arch.lifecycle.LiveData;
import android.arch.lifecycle.Observer;
import android.support.annotation.MainThread;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

/**
 * Created by hubert on 2017/12/7.
 * <p>
 * 用于ActionLiveData的转换,实现Action的传递
 */

public class ActionTransformations {

    @MainThread
    public static <X, Y> ActionLiveData<Y> map(@NonNull ActionLiveData<X> source,
                                               @NonNull final Function<X, Y> func) {
        final ActionLiveData<Y> result = new ActionLiveData<>();
        result.addSource(source, new ActionObserver<X>() {
            @Override
            public void onChanged(@Nullable X x) {
                result.setValue(func.apply(x));
            }

            @Override
            public void onAction(int id, Object... args) {
                result.setAction(id, args);
            }
        });
        return result;
    }

    @MainThread
    public static <X, Y> ActionLiveData<Y> switchMap(@NonNull LiveData<X> trigger,
                                                     @NonNull final Function<X, ActionLiveData<Y>> func) {
        final ActionLiveData<Y> result = new ActionLiveData<>();
        result.addSource(trigger, new Observer<X>() {
            ActionLiveData<Y> mSource;

            @Override
            public void onChanged(@Nullable X x) {
                ActionLiveData<Y> newLiveData = func.apply(x);
                if (mSource == newLiveData) {
                    return;
                }
                if (mSource != null) {
                    result.removeSource(mSource);
                }
                mSource = newLiveData;
                if (mSource != null) {
                    result.addSource(mSource, new ActionObserver<Y>() {
                        @Override
                        public void onAction(int id, Object... args) {
                            result.setAction(id, args);
                        }

                        @Override
                        public void onChanged(@Nullable Y y) {
                            result.setValue(y);
                        }
                    });
                }
            }
        });
        return result;
    }
}

使用时也没有多大的改变,只要把LiveData替换成ActionLiveData即可。开始尽情的传递事件吧~ ��

这个扩展是本人根据需求独创的,如果觉得好不要吝惜你的“喜欢”哦。 当然由于水平有限,如果入不了你的眼,那肯定是比我厉害的大牛,有更好的建议或者思路可以提点我一下��,让我也学习学习~

展开阅读全文

没有更多推荐了,返回首页