Android jetpack 架构组件复习----LiveDataLiveData is a data holder

简介

LiveData is a data holder class that can be observed within a given lifecycle. This means that an Observer can be added in a pair with a LifecycleOwner, and this observer will be notified about modifications of the wrapped data only if the paired LifecycleOwner is in active state. LifecycleOwner is considered as active, if its state is STARTED or RESUMED. An observer added via observeForever is considered as always active and thus will be always notified about modifications. For those observers, you should manually call removeObserver.

LiveData是一个存放数据的类，它可以在指定的生命周期下被观察。这意味着，可以添加一个 Observer , 并且和LifecycleOwner配对上，这个observer只会在对应的LifecycleOwner处于Active状态时，并且包装的数据发生变化时，才会被通知。当LifecycleOwner的状态是 STARTED 或者 RESUMED 时，才被认为是 Active 。如果一个observer是通过 observeForever 添加的，那么，这被认为是总是处于 Active状态，所以只要包装的数据发生变化，就会收到通知，不管LifecycleOwner处于什么生命周期的状态。对于这样的情况，你要手动调用 removeObserver，在不再需要监听包装数据的变化时。

An observer added with a Lifecycle will be automatically removed if the corresponding Lifecycle moves to DESTROYED state. This is especially useful for activities and fragments where they can safely observe LiveData and not worry about leaks: they will be instantly unsubscribed when they are destroyed.

与生命周期相关的observer，会在Lifecycle切换到 DESTROYED状态时，自动移除数据的监听。这对activities和fragments，特别有用，它们可以安全的观察，监听LiveData而不用担心内存泄漏：当activities和fragments处于destroyed状态时，自动立即解除数据的监听。

In addition, LiveData has onActive and onInactive methods to get notified when number of active Observers change between 0 and 1. This allows LiveData to release any heavy resources when it does not have any Observers that are actively observing.

此外，LiveData有 onActive 和 onInactive 这两个回调方法，当活跃的 Observer 数量在 0 和 1之间切换时，这两个回调方法会被调用。这样，LiveData就可以释放掉任何大量的数据，当没有活跃的Observers观察时。

This class is designed to hold individual data fields of ViewModel, but can also be used for sharing data between different modules in your application in a decoupled fashion.

示例

LifeCycleOwner和ViewModel，LiveData之间的关系：

创建LiveData实例，指定源数据类型
创建Observer实例，实现onChanged()方法，用于接收源数据变化并刷新UI
LiveData实例使用observe()方法添加观察者，并传入LifecycleOwner
LiveData实例使用setValue()/postValue()更新源数据（子线程要postValue()）

LiveData 什么时候算 Active？

官方定义（简化一下）：

只有当 LifecycleOwner 的状态是 STARTED 或 RESUMED 时，Observer 才是 active 的。

也就是：

Lifecycle 回调	对应状态	LiveData 是否 Active
onCreate	CREATED	❌ inactive
onStart	STARTED	✅ active
onResume	RESUMED	✅ active
onPause	`RESUMED → STARTED`	✅ active
onStop	`STARTED → CREATED`	❌ inactive
onDestroy	DESTROYED	❌ inactive

public class LiveDataTestActivity extends AppCompatActivity{

   private MutableLiveData<String> mLiveData;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_lifecycle_test);
       
       //liveData基本使用
       mLiveData = new MutableLiveData<>();
       mLiveData.observe(this, new Observer<String>() {
           @Override
           public void onChanged(String s) {
               Log.i(TAG, "onChanged: "+s);
           }
       });
       Log.i(TAG, "onCreate: ");
       mLiveData.setValue("onCreate");//activity是非活跃状态，不会回调onChanged。变为活跃时，value被onStart中的value覆盖
   }
   @Override
   protected void onStart() {
       super.onStart();
       Log.i(TAG, "onStart: ");
       mLiveData.setValue("onStart");//活跃状态，会回调onChanged。并且value会覆盖onCreate、onStop中设置的value
   }
   @Override
   protected void onResume() {
       super.onResume();
       Log.i(TAG, "onResume: ");
       mLiveData.setValue("onResume");//活跃状态，回调onChanged
   }
   @Override
   protected void onPause() {
       super.onPause();
       Log.i(TAG, "onPause: ");
       mLiveData.setValue("onPause");//活跃状态，回调onChanged
   }
   @Override
   protected void onStop() {
       super.onStop();
       Log.i(TAG, "onStop: ");
       mLiveData.setValue("onStop");//非活跃状态，不会回调onChanged。后面变为活跃时，value被onStart中的value覆盖
   }
   @Override
   protected void onDestroy() {
       super.onDestroy();
       Log.i(TAG, "onDestroy: ");
       mLiveData.setValue("onDestroy");//非活跃状态，且此时Observer已被移除，不会回调onChanged
   }
}

注意到 LiveData实例mLiveData的创建是使用MutableLiveData，它是LiveData的实现类，且指定了源数据的类型为String。然后创建了接口Observer的实例，实现其onChanged()方法，用于接收源数据的变化。observer和Activity一起作为参数调用mLiveData的observe()方法，表示observer开始观察mLiveData。然后Activity的所有生命周期方法中都调用了mLiveData的setValue()方法。

多个观察者

这里其实没有一个枚举叫 “PAUSED” 或 “STOPPED”，这是我们日常口头描述 Activity 状态时用的词。
严格来说：

“Paused” ≈ STARTED（可见但不在前台、没焦点）
“Stopped” ≈ CREATED 或更低（不可见）

所以你看到那句：

如果一个观察者处于 Paused 或 Destroyed 状态，它将不会受到通知。

实际上是不严谨 / 错的说法。
Paused（onPause 之后到 onStop 之前）其实还是 active，会收到通知。
真正不会通知的是：Stopped（onStop 之后）和 Destroyed。

从上图可以看到，LiveData 的数据来源一般是 ViewModel，或者其它用来更新 LiveData 的组件。一旦数据更新后，LiveData 就会通知它的所有观察者，例如 Activity、Fragment、Service 等组件。但是，与其他类似 RxJava 的方法不同的是，LiveData 并不是盲目的通知所有观察者，而是首先检查它们的实时状态。LiveData 只会通知处于 Actie 的观察者，如果一个观察者处于 Stopped 或 Destroyed 状态，它将不会受到通知。这样的好处是，我们不需要在 onStop 或 onDestroy 方法中解除对 LiveData 的订阅/观察。此外，一旦观察者重新恢复 Resumed 状态，它将会重新收到 LiveData 的最新数据。

自定义LiveData，被多个组件共享

自定义LiveData，本身回调方法的覆写：onActive()、onInactive()。
实现LiveData为单例模式，便于在多个Activity、Fragment之间共享数据。

public class StockLiveData extends LiveData<BigDecimal> {
        private static StockLiveData sInstance; //单实例
        private StockManager stockManager;

        private SimplePriceListener listener = new SimplePriceListener() {
            @Override
            public void onPriceChanged(BigDecimal price) {
                setValue(price);//监听到股价变化 使用setValue(price) 告知所有活跃观察者
            }
        };

	//获取单例
        @MainThread
        public static StockLiveData get(String symbol) {
            if (sInstance == null) {
                sInstance = new StockLiveData(symbol);
            }
            return sInstance;
        }

        private StockLiveData(String symbol) {
            stockManager = new StockManager(symbol);
        }

     	//活跃的观察者（LifecycleOwner）数量从 0 变为 1 时调用
        @Override
        protected void onActive() {
            stockManager.requestPriceUpdates(listener);//开始观察股价更新
        }

     	//活跃的观察者（LifecycleOwner）数量从 1 变为 0 时调用。这不代表没有观察者了，可能是全都不活跃了。可以使用hasObservers()检查是否有观察者。
        @Override
        protected void onInactive() {
            stockManager.removeUpdates(listener);//移除股价更新的观察
        }
    }

为了观察股票价格变动，继承LiveData自定义了StockLiveData，且为单例模式，只能通过get(String symbol)方法获取实例。并且重写了onActive()、onInactive()，并加入了开始观察股价更新、移除股价更新观察的逻辑。

onActive()调用时机为：活跃的观察者（LifecycleOwner）数量从 0 变为 1 时。
onInactive()调用时机为：活跃的观察者（LifecycleOwner）数量从 1 变为 0 时。

也就是说，只有当存在活跃的观察者（LifecycleOwner）时才会连接到股价更新服务监听股价变化。使用如下：

    public class MyFragment extends Fragment {
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            //获取StockLiveData单实例，添加观察者，更新UI
            StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {
                // Update the UI.
            });
        }
    }

Transformations方法

如果希望在将 LiveData 对象分派给观察者之前对存储在其中的值进行更改，或者需要根据另一个实例的值返回不同的 LiveData 实例，可以使用LiveData中提供的Transformations类。

数据修改 - Transformations.map

        //Integer类型的liveData1
        MutableLiveData<Integer> liveData1 = new MutableLiveData<>();
        //转换成String类型的liveDataMap
        LiveData<String> liveDataMap = Transformations.map(liveData1, new Function<Integer, String>() {
            @Override
            public String apply(Integer input) {
                String s = input + " + Transformations.map";
                Log.i(TAG, "apply: " + s);
                return s;
            }
        });
        liveDataMap.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged1: "+s);
            }
        });

        liveData1.setValue(100);

使用很简单：原本的liveData1 没有添加观察者，而是使用Transformations.map()方法对liveData1的数据进行的修改生成了新的liveDataMap，liveDataMap添加观察者，最后liveData1设置数据。

此例子把 Integer类型的liveData1 修改为String类型的liveDataMap。结果如下：

apply: 100 + Transformations.map
onChanged1: 100 + Transformations.map

数据切换 - Transformations.switchMap

如果想要根据某个值切换观察不同LiveData数据，则可以使用Transformations.switchMap()方法。

	//两个liveData，由liveDataSwitch决定 返回哪个livaData数据
        MutableLiveData<String> liveData3 = new MutableLiveData<>();
        MutableLiveData<String> liveData4 = new MutableLiveData<>();
        
	//切换条件LiveData，liveDataSwitch的value 是切换条件
        MutableLiveData<Boolean> liveDataSwitch = new MutableLiveData<>();
        
	//liveDataSwitchMap由switchMap()方法生成，用于添加观察者
        LiveData<String> liveDataSwitchMap = Transformations.switchMap(liveDataSwitch, new Function<Boolean, LiveData<String>>() {
            @Override
            public LiveData<String> apply(Boolean input) {
            //这里是具体切换逻辑：根据liveDataSwitch的value返回哪个liveData
                if (input) {
                    return liveData3;
                }
                return liveData4;
            }
        });

        liveDataSwitchMap.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged2: " + s);
            }
        });

        boolean switchValue = true;
        liveDataSwitch.setValue(switchValue);//设置切换条件值

        liveData3.setValue("liveData3");
        liveData4.setValue("liveData4");

liveData3、liveData4是两个数据源，有一个判断条件来决定取哪一个数据，这个条件就是liveDataSwitch，如果值为true则取liveData3，false则取liveData4。 Transformations.switchMap()就用于实现这一逻辑，返回值liveDataSwitchMap添加观察者就可以了。结果如下：

switchValue=true
onChanged2: liveData3

观察多个数据 - MediatorLiveData

MediatorLiveData 是 LiveData 的子类，允许合并多个 LiveData 源。只要任何原始的 LiveData 源对象发生更改，就会触发 MediatorLiveData 对象的观察者。

        MediatorLiveData<String> mediatorLiveData = new MediatorLiveData<>();

        MutableLiveData<String> liveData5 = new MutableLiveData<>();
        MutableLiveData<String> liveData6 = new MutableLiveData<>();

	//添加 源 LiveData
        mediatorLiveData.addSource(liveData5, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged3: " + s);
                mediatorLiveData.setValue(s);
            }
        });
	//添加 源 LiveData
        mediatorLiveData.addSource(liveData6, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged4: " + s);
                mediatorLiveData.setValue(s);
            }
        });

	//添加观察
        mediatorLiveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                Log.i(TAG, "onChanged5: "+s);
                //无论liveData5、liveData6更新，都可以接收到
            }
        });
        
        liveData5.setValue("liveData5");
        //liveData6.setValue("liveData6");

例如，如果界面中有可以从本地数据库或网络更新的 LiveData 对象，则可以向 MediatorLiveData 对象添加以下源：

与存储在本地数据库中的数据关联的 liveData5
与从网络访问的数据关联的 liveData6 Activity 只需观察 MediatorLiveData 对象即可从这两个源接收更新。结果如下：

onChanged3: liveData5
onChanged5: liveData5

（Transformations也是对MediatorLiveData的使用。）