【翻译】安卓架构组件(4)-LiveData

【翻译】安卓架构组件(1)-App架构指导
【翻译】安卓架构组件(2)-添加组件到你的项目中
【翻译】安卓架构组件(3)-处理生命周期
【翻译】安卓架构组件(5)-ViewModel
【翻译】安卓架构组件(6)-Room持久化类库
【翻译】安卓架构组件(7)-分页库

LiveData是一个数据持有类，保存了数据值以及允许该值被观察。并不像常规的被观察者，LiveData遵循app组件的生命周期，例如Observer可以指定要观察的Lifecyle。

如果Observer的Lifecycle是STARTED或者RESUMED状态，则LiveData认为其处在激活状态。

public class LocationLiveData extends LiveData {
    private LocationManager locationManager;

    private SimpleLocationListener listener = new SimpleLocationListener() {
        @Override
        public void onLocationChanged(Location location) {
            setValue(location);
        }
    };

    public LocationLiveData(Context context) {
        locationManager = (LocationManager) context.getSystemService(
                Context.LOCATION_SERVICE);
    }

    @Override
    protected void onActive() {
        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, listener);
    }

    @Override
    protected void onInactive() {
        locationManager.removeUpdates(listener);
    }
}

在Location监听器的实现中有三个重要的地方：

onActive()：当LiveData拥有一个处在激活状态的观察者时会调用这个方法。这意味着我们需要开始观察位置信息的更新
onInactive()：当LiveData并不拥有任何处在激活状态时这个方法被调用。既然没有任何观察者进行监听，那么没有理由继续保持对LocationManager服务的连接
setValue()：调用该方法更新LiveData实例的值，并通知处在激活状态的观察者该变化

我们可以这样使用新的LocationLiveData：

public class MyFragment extends LifecycleFragment {
    public void onActivityCreated (Bundle savedInstanceState) {
        LiveData myLocationListener = ...;
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.observer(this, location -> {
                    // 更新 UI
                });
            }
        });
    }
}

注意到addObserver()方法传递的第一个参数是LifecycleOwner，这表示观察者必然绑定至Lifecycle，这意味着：

如果Lifecycle并不处在激活状态，即使值发生变化，观察者也不会被响应
如果Lifecycle被销毁，观察者会被自动清除

LiveData是生命周期敏感的，这提供给了我们一个新的机会：我们可以在多个Activity、多个Fragment间共享。为了保持我们样例代码的简洁，我们将它变成单例：

public class LocationLiveData extends LiveData {
    private static LocationLiveData sInstance;
    private LocationManager locationManager;

    @MainThread
    public static LocationLiveData get(Context context) {
        if (sInstance == null) {
            sInstance = new LocationLiveData(context.getApplicationContext());
        }
        return sInstance;
    }

    private SimpleLocationListener listener = new SimpleLocationListener() {
        @Override
        public void onLocationChanged(Location location) {
            setValue(location);
        }
    };

    private LocationLiveData(Context context) {
        locationManager = (LocationManager) context.getSystemService(
                Context.LOCATION_SERVICE);
    }

    @Override
    protected void onActive() {
        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, listener);
    }

    @Override
    protected void onInactive() {
        locationManager.removeUpdates(listener);
    }
}

现在Fragment可以这样用：

public class MyFragment extends LifecycleFragment {
    public void onActivityCreated (Bundle savedInstanceState) {
        Util.checkUserStatus(result -> {
            if (result) {
                LocationLiveData.get(getActivity()).observe(this, location -> {
                   // 更新 UI
                });
            }
        });
  }
}

可能会有多个Fragment和多个Activity观察我们的MyLocationListener实例，并且只要它们处在激活状态，我们的LiveData可以优雅地进行管理。

LiveData类具有如下的优点：

没有内存泄漏：因为Obeserver们被绑定在自己的Lifecycle对象，当Lifecycle被销毁的时候，它们会被自动清除
停止Activity的时候不会发生崩溃：如果Obeserver们的Lifecycle对象处在非激活状态（如Activity在后台），它们将不会接收任何变化事件
总是更新数据：如果Lifecycle再次启动（例如一个Activity从后台回到前台），它将会收到最新的本地数据
正确的配置变化：如果一个Activity或一个Fragment由于配置的变化（如屏幕旋转）重新创建，它将会立刻收到最新的Location数据
共享资源：现在我们可以持有一个单独的MyLocationListener实例，只需要连接到系统服务一次，并且可以正确地支持app里的所有观察者
不需要手动处理生命周期：你应该注意到，我们的Fragment仅仅当想要的时候观察数据，不需要关心如何停止，以及在停止后的再次开启。LiveData会自动管理所有的情况，因为Fragment提供了其Lifecycle。

`LiveData`转换

有些时候，你可能想要在分发LiveData至观察者之前做一些变化，或者需要基于当前值返回另一个LiveData实例。

Lifecycle包提供了一个Transformations类，包含这些操作的辅助方法。

`Transformations.map()`

对LiveData值应用一个函数，传递结果至下流。

LiveData userLiveData = ...;
LiveData userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

`Transformations.switchMap()`

和map()相似，传递至switchMap()的函数必须返回一个Lifecycle。

private LiveData getUser(String id) {
  ...;
}


LiveData userId = ...;LiveData user = Transformations.switchMap(userId, id -> getUser(id) );

使用这些转化允许通过链继续观察Lifecycle信息，例如这些信息只有当一个观察者观察返回LiveData的时才进行计算。这种惰性计算的特性允许在转化过程中隐式地传递生命周期，而不需要添加额外的调用或依赖。

当你在ViewModel里需要一个Lifecycle时，一个转化可能是一种解决方案。

例如，假设我们有一个UI界面，用户输入地址并接收地址的邮政编码。UI界面原始的ViewModel是这样的：

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    public MyViewModel(PostalCodeRepository repository) {
       this.repository = repository;
    }

    private LiveData getPostalCode(String address) {
       // 不要这样做！
       return repository.getPostCode(address);
    }
}

实现如上，UI可能需要从之前的LiveData反注销并在每次调用getPostalCode()新的实例时重新注册。此外，如果UI是重新创建的，它出发了另一个调用repository.getPostCode()，而不是之前的结果。

作为上述方法的替换，你可以将邮政编码信息作为地址信息输入的转换：

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

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

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

注意到我们将postalCode设为public final，因为它永远不会改变。它被定义为addressInput的转化，因此当addressInput变化的时候，如果有一个激活的观察者，repository.getPostCode()会被调用。如果没有激活的观察者，则不会有任何计算发生，直到添加了一个观察者。

这种机制允许下层的应用创建LiveData对象，在需要的时候才计算。ViewModel可以轻易地获取它们并在上层定义转化规则。

【翻译】安卓架构组件(4)-LiveData

LiveData转换

Transformations.map()

Transformations.switchMap()

你可能感兴趣的:(【翻译】安卓架构组件(4)-LiveData)

`LiveData`转换

`Transformations.map()`

`Transformations.switchMap()`