LiveData

LiveData 是一个 data holder 类，持有一个可被观察的值。与普通的observable不同的是，LiveData遵循app 组件的生命周期。它能决定在某个生命周期是否被观察

LiveData 在观察者生命周期的 STARTED 和 RESUMED 状态是可被激活的

public class LocationLiveData extends LiveData<Location> {
    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);
    }
}

• onActive()：当LiveData增加了一个observer 时被调用。这表示开始监听设备的location
• onInactive()：当LiveData没有一个observer 时被调用。没有observer监听所以没必要去连接LocationManager service.
• setValue()：更新LiveData中value，并通知激活状态下的observers

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

addObserver() 方法第一个参数是 LifecycleOwner，这以为着这个 LiveData 被绑定到 LifeCycle 上

• 如果Lifecycle 不在 STARTED or RESUMED 状态，当value 变化是 observer 不会被通知
• 如果 Lifecycle 销毁了，observer 会自动移除

我们可以通过 LiveData 在 Activity 和 fragment 直接共享数据，比如

public class LocationLiveData extends LiveData<Location> {
    // 单例模式
    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 -> {
                   // update UI
                });
            }
        });
  }
}

这样就可以多个 fragment Activity 观察MyLocationListener实例，LiveData 可以比较优雅的管理这些 obverser

LiveData 还有以下几个优势

• 没有内存泄露：因为Observer被关联在了 Lifecycle对象中，所以他们能在生命周期 destory 的时候自动解除关联
• 没有因为 Activity stop 而产生的 crash ：如果Observer 的Lifecycle不在激活的生命周期内。
• 始终保持最新的数据：如果 Lifecycle重新启动（比如 Activity 重新start），会重新收到数据
• 正确的config更改：如果由于配置更改（如设备旋转）而重新创建Activity或fragment，则会立即接收最后一个可用位置数据。
• 共享资源：可以只保留一个MyLocationListener的实例只需连接系统服务一次，就可以支持应用内所有的observers
• 不需要手动处理生命周期：fragment 只在需要的时候观察数据，不用担心被stop或在stop后开始观察。因为fragment 在观察时提供了其生命周期，LiveData自动管理所有这一切

Transformations of LiveData

有时候，您可能需要在将其分配给观察者之前对LiveData值进行更改，否则可能需要根据另一个LiveData实例返回不同的LiveData实例

Lifecycle包提供了一个Transformations类，其中包含这些操作的帮助方法（类似于 Rxjava map）。

Transformations.map()

应用一个函数作用在LiveData上，并将结果传播到下游。

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

Transformations.switchMap()

与map（）类似，将一个函数应用于该值并展开并将结果分派到下游。传递给switchMap（）的函数必须返回一个Lifecycle

private LiveData<User> getUser(String id) {
  ...;
}

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

map 是把一个数据类型变换为另外一个数据类型。
switchMap 是把一个数据变化为另外一个 LiveData

使用这些转换允许在整个调用链中携带观察者的 Lifecycle 信息，以便只有在观察者观察到 LiveData 的返回时才运算这些转换。转换的这种惰性运算性质允许隐式的传递生命周期相关行为，而不必添加显式的调用或依赖。

每当您认为在ViewModel中需要一个Lifecycle对象时，转换可能就是解决方案。

例如：假设有一个 UI，用户输入一个地址然后会收到该地址的邮政编码。该 UI 简单的 ViewModel 可能像这样：

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

    private LiveData<String> getPostalCode(String address) {
       // DON'T DO THIS
       return repository.getPostCode(address);
    }
}

如果这是实现，UI将需要从先前的LiveData注销，并在每次调用getPostalCode（）时重新注册到新的实例。此外，如果UI被重新创建，它会触发对repository.getPostCode（）的另一个调用，而不是使用以前的调用结果。

而不是使用这种方法，您可以实现邮政编码信息作为地址输入的转换：

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);
  }
}

我们甚至使邮政编码字段为public final，因为它永远不会更改。postalCode 被定义为addressInput的转换，所以当addressInput更改时，如果存在活动的观察者，则会调用repository.getPostCode（）。如果在调用时没有处于活动状态的观察者，在添加观察者之前不会进行任何运算。

该机制允许以较少的资源根据需要惰性运算来创建 LiveData。ViewModel 可以轻松获取到 LiveData 并在它们上面定义转换规则。

创建新的转换

在应用程序中可能会用到十几种不同的特定转换，但是默认是不提供的。可以使用 MediatorLiveData 实现自己的转换，MediatorLiveData 是为了用来正确的监听其它 LiveData 实例并处理它们发出的事件而特别创建的。MediatorLiveData 需要特别注意正确的向源 LiveData 传递其处于活动/闲置状态。有关详细信息，请参阅 Transformations 类。

参考

https://juejin.im/post/5937e402a0bb9f005808d00e
https://developer.android.com/topic/libraries/architecture/livedata.html#transformations_of_livedata