Android之MVVM架构指南（四）：LiveData

Livedata 是一个数据源的包装类，他可以有效的取代请求信息时用到callback接口，还可以配合Lifecycle感知程序组件生命周期。

正常我们请求网络数据时的代码为：

public class ListActivity extends AppCompatActivity {
    private TextView userNameTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userNameTv = findViewbyId(R.id.user_name);
        NetModel.getUserName().callback(new Callback(){

            @Override
            public void onSuccess(String userName){
                userNameTv.setText(userName);
            }

        });
    }
}

同样的功能使用LiveData可以写为：

public class ListActivity extends AppCompatActivity {

    private TextView userNameTv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userNameTv = findViewbyId(R.id.user_name);
        LiveData<String> userName = NetModel.getUserName();
        userName.observe(this, new Observer<String>() {
            @Override
            public void onChanged(@Nullable String name) {
               userNameTv.setText(name);
            }
        });
    }
}

使用时看上去并没有简化多少，但是相比之前的原始代码，如果原始代码中不对setText()方法添加生命周期的判断，当activity销毁后可能会引发空指针异常。

而在LiveData的observe方法中需要传入一个LifecycleOwner对象，所以LiveData可以感知宿主的生命周期，从而不用担心此类问题。

创建Livedata对象

Livedata 属于包装类，所以需要先创建一个Livedata对象，然后在为其填充数据。

Livedata 是一个一个抽象类，不能直接实例化，Android 默认提供了一个它的子类MutableLiveData，其源码如下：

public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

有没有一脸懵逼的感觉？其实这么写的原因是因为Livedata类添加数据的setValue()和postValue()方法的权限不是公开的，而MutableLiveData只是将这两个方法权限公开而已。

为什么要这样做呢？主要是考虑到架构模型的问题，在数据源请求处使用MutableLiveData对象添加数据，而在UI操作的地方使用LiveData对象就只能使用数据无法改变其数据，这样的话就做到了数据只能在一个地方发生改变提升系统稳定性。当然如果你希望在任何地方都可以改变数据源，直接全部使用MutableLiveData对象即可。

至于设置数据的两个方法：

• setValue()，在UI线程设置数据。
• postValue()，在worker线程设置数据。

具体使用方法：

final MutableLiveData<String> data = new MutableLiveData<>();
data.setValue("test");

// in Worker Thread used
data.postValue("test");

感知生命周期

当我们调用LiveData的observe(LifecycleOwner owner,Observer<T> observer)时，LiveData会在LifecycleOwner中添加一个监听生命周期的观察者，

• 当生命周期处于STARTED或RESUMED这种活动状态时才会通知Observer数据更新
• 当生命周期处于非活动状态时Observer不会接收到数据更新的通知
• 当生命周期处于DESTROYED时会将监听生命周期的观察者删除

扩展使用

在上面生命周期的三种情况中，LiveData 除了内部的逻辑操作外，还提供了跟生命周期状态有关的两个回调方法：

• onActive() ，当生命周期观察者处于活动状态后调用。

• onInactive()，当生命周期观察者处于非活动状态后调用。

基于此，我们可以继承 LiveData进行扩展实现定制化，下面举一个定位的例子：

public class LocationLiveData extends LiveData<Position> {

	  // 定位管理器
    private LocationManager mLocationManager;

    public LocationLiveData() {
        mLocationManager = new LocationManager(new LocationCallback() {
            @Override
            public void onUpdate(Position position) {
				   // 当位置信息更新时重置livedata数据
                setValue(position);
            }
        });
    }

    @Override
    protected void onActive() {
		  // 生命周期处于活动状态时开启定位
        mLocationManager.startLocation();
    }

    @Override
    protected void onInactive() {
		   //生命周期处于非活动状态时关闭定位
        mLocationManager.stopLocation();
    }
}

上面的代码将定位功能封装到了Livedata中，隐藏细节的同时并具备了感知生命周期的能力，在实际使用中只需要像标准的LiveData使用一样即可：

public class LocationFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        
        LiveData<Position> position = new LocationLiveData();
        position.observe(this,new Observer(){
            @Override
            public void onChanged(Position position) {
                // 更新UI
            }
        });
    }
}

不仅如此，我们知道 LiveData 中的observe()方法需要传入一个LifecycleOwner对象用来感知生命周期，但是它并不是唯一值，也就是说我们能够通过observe()方法同时为一个liveData对象设置两个Activity/Fragment的生命周期宿主，也就是LifecycleOwner，基于这个特性，我们可以将LiveData设置成单例模式从而实现多个组件间共享数据。

public class LocationLiveData extends LiveData<Position> {
    private LocationManager mLocationManager;

    private LocationLiveData instance;

    public static LocationLiveData get(){
        if (instance == null) {
            instance = new LocationLiveData();
        }
        return instance;
    }


    private LocationLiveData() {
        mLocationManager = new LocationManager(new LocationCallback() {
            @Override
            public void onUpdate(Position position) {
                setValue(position);
            }
        });
    }

    @Override
    protected void onActive() {
        mLocationManager.startLocation();
    }

    @Override
    protected void onInactive() {
        mLocationManager.stopLocation();
    }
}

在不同的组件中调用：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        
        LocationLiveData.get().observe(this,new Observer(){
            @Override
            public void onChanged(Position position) {
                // 更新UI
            }
        });
    }
}


public class Fragment2 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        
        LocationLiveData.get().observe(this,new Observer(){
            @Override
            public void onChanged(Position position) {
                // 更新UI
            }
        });
    }
}

变换

这个功能跟RxJava的变换很像，说白了就是抄的RxJava的功能，实现变换功能的是Transformations类，它提供了两个变化的方法。

map() 方法

假设我们要实现一个获取所有用户的用户名功能，但是我们只有获取所有用户的接口：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
       
        NetModel.getAllUser().observe(this, new Observer<List<user>>() {
            @Override
            public void onChanged(@Nullable List<User> users) {
                // 获取到所有用户在去拿用户名
                List<String> allUserName = new ArrayList<>();
                for (User user : users) {
                    allUserName.add(user.getUserName());
                }
                // 更新UI
            }
        });
    }
}

使用 map() 方法效果如下：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        
        LiveData<List<String>> data = Transformations.map(NetModel.getAllUser(), new Function<List<User>, List<String>>() {
            @Override
            public List<String> apply(List<User> input) {
                List<String> allUserName = new ArrayList<>();
                for (User user : users) {
                    allUserName.add(user.getUserName());
                }
                return allUserName;
            }
        });

        data.observe(this, new Observer<List<String>>() {
            @Override
            public void onChanged(@Nullable List<String> strings) {
                // 更新UI
            }
        });


    }
}

这样做的好处除了转变操作也能感知生命周期外，更重要的是业务逻辑分离，onChanged()方法中只做更新UI的操作，代码更加健壮。

switchMap() 方法

这两种方法唯一不同的地方就是map()的变换是从一个数据源变成另外一个数据源，而switchMap()是从一个数据源变成另外一个LiveData对象，具体有什么用呢？

举一个例子，我们想实现一个获取用户所有信息的功能，但是我们需要先获取用户的id，才能通过id获取信息：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        NetModel.getUserId().observe(this,new Observer<String>(){
            @Override
            public void onChanged(String id){
                NetModel.getUserInfo(id).observe(Fragment1.this,new Observer<User>(){
                    @Override
                    public void onChanged(User user){
                        // 更新UI
                    }
                })
            }
       });
    }
}

很明显，看着就不爽，用switchMap() 实现效果如下：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        LiveData<User> user = Transformations.switchMap(NetModel.getUserId(), new Function<String, LiveData<User>() {
            @Override
            public LiveData<User> apply(String id) {
                return Model.getUserInfo(id);
            }
        });

        user.observe(this, new Observer<User>() {
            @Override
            public void onChanged(@Nullable List<User> users) {
                // 更新UI
            }
        });

    }
}

同样的道理，这么做不光方便管理，代码更加健壮。

合并多个LiveData

假设我们有一个获取用户信息的功能，用户信息既可以在网络获取也可以在本地缓存中获取，需要怎么实现呢？

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
       
        LocalModel.getUserInfo().observe(this, new Observer<User>() {
            @Override
            public void onChanged(@Nullable List<User> users) {
                // 更新UI
            }
        });

        NetModel.getUserInfo().observe(this, new Observer<User>() {
            @Override
            public void onChanged(@Nullable List<User> users) {
                // 更新UI
            }
        });

    }
}

上面代码有一个严重的缺陷，那就是两个observer中更新UI代码其实是一样的，这是冗余代码很垃圾，那应该怎么做呢？Android提供了一个可以将多个LiveData 对象合并成一个Livedata的功能类：MediatorLiveData，使用方法如下：

public class Fragment1 extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
       
        MediatorLiveData<User> data = new MediatorLiveData();
        data.addSource(LocalModel.getUserInfo(), new Observer<User>() {
            @Override
            public void onChanged(@Nullable User user) {
                data.setValue(user);
            }
        });
        data.addSource(NetModel.getUserInfo(), new Observer<User>() {
            @Override
            public void onChanged(@Nullable User user) {
                data.setValue(user);
            }
        });
        data.observe(this,new Observer<User>() {
            @Override
            public void onChanged(@Nullable User user) {
                // 更新UI
            }
        });

    }
}

MediatorLiveData 通过addSource()方法可以观察多个Livedata对象的数据变化。