LiveData library使用

在Model - build.gradle添加依赖

implementation "android.arch.lifecycle:livedata:1.1.1"

LiveData是一个可观察的数据持有者类。与常规可观察性不同，LiveData具有生命周期感知能力，这意味着它尊重其他应用程序组件的生命周期，例如活动，片段或服务。这种意识确保LiveData仅更新处于活动生命周期状态的应用程序组件观察者。

注意：要将LiveData组件导入到Android项目中，请参阅向项目添加组件。

如果LiveData的Observer生命周期处于STARTED或 RESUMED 状态，LiveData将认为由该类表示的观察者 处于活动 状态。LiveData仅通知活跃的观察员关于更新。LiveData未注册观察对象的非活动观察者 不会收到有关更改的通知。

您可以注册与实现该LifecycleOwner 接口的对象配对的观察者 。这种关系允许观察者在对应Lifecycle对象的状态改变 时被移除 DESTROYED。这对活动和碎片特别有用，因为它们可以安全地观察LiveData对象并且不用担心泄漏 - 活动和碎片在其生命周期被破坏时会立即取消订阅。

有关如何使用LiveData的更多信息，请参阅使用LiveData对象。

使用LiveData的优点

使用LiveData提供以下优点：

确保您的用户界面符合您的数据状态

LiveData遵循观察者模式。Observer当生命周期状态改变时，LiveData会通知 对象。您可以合并代码以更新这些Observer对象中的UI 。每次应用程序数据更改时，您的观察者都可以在每次更改时更新UI，而不是每次更新UI。

没有内存泄漏

Lifecycle当关联的生命周期被破坏时，观察者被绑定到 对象并自行清理。

由于停止活动而没有崩溃

如果观察者的生命周期处于非活动状态，例如在后退堆栈中的活动，则它不会收到任何LiveData事件。

没有更多的手动生命周期处理

UI组件只是观察相关数据，不要停止或恢复观察。LiveData自动管理所有这些，因为它在观察时意识到相关的生命周期状态更改。

始终保持最新的数据

如果生命周期变为非活动状态，它将在再次变为活动状态时收到最新数据。例如，后台活动在返回到前台后立即收到最新数据。

正确的配置更改

如果由于配置更改（如设备旋转）而重新创建活动或片段，它会立即收到最新的可用数据。

共享资源

您可以LiveData 使用单例模式扩展对象以包装系统服务，以便它们可以在应用程序中共享。该LiveData对象连接到系统服务一次，然后任何需要该资源的观察者都可以观察该LiveData 对象。有关更多信息，请参阅扩展LiveData。

使用LiveData对象

---

按照以下步骤操作 LiveData对象：

1. 创建一个实例LiveData来保存某种类型的数据。这通常在你的ViewModel班级内完成 。

2. 创建一个Observer 定义onChanged() 方法的对象，该对象 控制LiveData对象保存的数据更改时发生的情况。您通常Observer在UI控制器中创建对象，例如活动或片段。

3. 使用该 方法将Observer对象附加到对象。该方法需要一个 对象。这将对象订阅到对象，以便通知其更改。您通常将该对象附加到UI控制器中，例如活动或片段。LiveDataobserve()observe()LifecycleOwnerObserver``LiveData``Observer

   注意：您可以LifecycleOwner使用该observeForever(Observer) 方法注册一个没有关联对象 的观察者 。在这种情况下，观察者被认为始终处于活动状态，因此总是通知修改。您可以删除这些观察者调用该 removeObserver(Observer) 方法。

更新存储在LiveData对象中的值时，只要附件LifecycleOwner处于活动状态，就会触发所有已注册的观察者。

LiveData允许UI控制器观察者订阅更新。当LiveData对象所持有的数据发生变化时，UI会自动更新。

创建LiveData对象

LiveData是一个包装器，可用于任何数据，包括实现的对象Collections，例如List。一个 LiveData对象通常存储在一个ViewModel 对象中，并通过getter方法访问，如以下示例所示：

public class NameViewModel extends ViewModel {
    // Create a LiveData with a Stringprivate MutableLiveData mCurrentName;   
    public MutableLiveData getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData();
        }
        return mCurrentName;
    }
    // Rest of the ViewModel...
}

最初，LiveData对象中的数据未设置。

注意： 由于以下原因，请确保存储将LiveData对象更新为UI的ViewModel对象，而不是活动或片段：

• 避免臃肿的活动和碎片。现在这些UI控制器负责显示数据但不保存数据状态。
• 将LiveData实例从特定活动或片段实例中分离出来，并允许LiveData对象在配置更改后继续存在。

你可以ViewModel在 ViewModel指南中阅读更多关于类的好处和用法。

观察LiveData对象

在大多数情况下，出于以下原因，应用程序组件的onCreate()方法是开始观察LiveData对象的正确位置 ：

• 确保系统不会从活动或片段的onResume()方法进行多余的调用。
• 确保活动或片段具有一旦它变为活动状态即可显示的数据。只要应用程序组件处于该 STARTED 状态，它就会从LiveData它正在观察的对象中接收最新值。只有当LiveData要观察的对象已被设置时才会发生这种情况。

通常，LiveData仅在数据更改时传递更新，并且仅传递给活动观察者。此行为的一个例外是，观察者在从非活动状态变为活动状态时也会收到更新。此外，如果观察者第二次从非激活状态变为激活状态，则只有在自上一次变为活动状态以来该值发生变化时才会收到更新。

以下示例代码说明了如何开始观察LiveData 对象：

public class NameActivity extends AppCompatActivity {
    private NameViewModel mModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Other code to setup the activity...       
        // Get the ViewModel.        
        mModel = ViewModelProviders.of(this).get(NameViewModel.class);
        // Create the observer which updates the UI.      
        final Observer nameObserver = new Observer() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.              
                mNameTextView.setText(newName);
            }
        };
        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.      
        mModel.getCurrentName().observe(this, nameObserver);
    }
}

经过 observe()了被称为nameObserver作为参数传递， onChanged() 被立即调用提供存储在最近的值mCurrentName。如果LiveData对象没有设置值mCurrentName，onChanged()则不会调用。

更新LiveData对象

LiveData没有公开可用的方法来更新存储的数据。本 MutableLiveData 类公开 setValue(T) 和 postValue(T) 方法公开，如果你需要编辑存储在一个值，你必须使用这些LiveData对象。通常 MutableLiveData用于， ViewModel然后 ViewModel唯一暴露LiveData给观察者的不可变对象。

建立观察者关系后，可以更新LiveData对象的值，如以下示例所示，当用户点击按钮时触发所有观察者：

mButton.setOnClickListener(new OnClickListener() {
    
        @Override
        public void onClick (View v){
            String anotherName = "John Doe";
            mModel.getCurrentName().setValue(anotherName);
        }
    });

调用setValue(T)示例会导致观察者onChanged() 使用该值调用其 方法John Doe。该示例示出了按钮按下，但 setValue()还是postValue()可以被调用以更新mName为各种各样的原因，包括响应于网络请求或数据库负荷完成; 在所有情况下，呼叫setValue()或postValue()触发观察员并更新UI。

注意：您必须调用 setValue(T) 方法来更新LiveData主线程中的对象。如果代码在工作线程中执行，则可以使用该 postValue(T) 方法更新该LiveData对象。

与房间一起使用LiveData

该厅持久库支持可观察到的查询，这回 LiveData对象。可观察查询是作为数据库访问对象（DAO）的一部分写入的。

LiveData当更新数据库时，会生成所有必要的代码以更新对象。生成的代码在需要时在后台线程上异步运行查询。该模式对于保持用户界面中显示的数据与存储在数据库中的数据保持同步非常有用。您可以在Room持久库指南中阅读关于Room和DAO的更多信息。

扩展LiveData

---

如果观察者的生命周期处于STARTED 或RESUMED 状态，则LiveData将认为观察者处于活动状态 。以下示例代码说明了如何扩展 LiveData该类：

public class StockLiveData extends LiveData {
    private StockManager mStockManager;
    private SimplePriceListener mListener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    public StockLiveData(String symbol) {
        mStockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        mStockManager.requestPriceUpdates(mListener);
    }

    @Override
    protected void onInactive() {
        mStockManager.removeUpdates(mListener);
    }
}

本示例中的价格监听器的实现包括以下重要方法：

• 该onActive() 方法在LiveData对象具有活动观察者时调用。这意味着您需要开始观察此方法的股价更新。
• onInactive() 当LiveData对象没有任何活动的观察者时调用该方法。由于没有观察员在倾听，因此没有理由保持与StockManager服务的连接 。
• 该setValue(T) 方法更新LiveData实例的值并通知任何活跃的观察者有关更改。

你可以使用这个StockLiveData类如下：

public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        LiveData myPriceListener = ...;
        myPriceListener.observe(this, price -> {
            // Update the UI.
        });
    }
}

该 observe()方法将片段LifecycleOwner作为第一个参数传递，该片段是一个实例 。这样做意味着这个观察者被绑定到Lifecycle与所有者相关的 对象上，这意味着：

• 如果Lifecycle对象不处于活动状态，则即使值发生更改，也不会调用观察者。
• 在之后Lifecycle的对象被破坏，观察者被自动删除。

LiveData对象是生命周期感知的事实意味着你可以在多个活动，片段和服务之间共享它们。为了保持示例简单，您可以LiveData按如下方式将该类实现为单例：

public class StockLiveData extends LiveData {
    private static StockLiveData sInstance;
    private StockManager mStockManager;
    private SimplePriceListener mListener = new SimplePriceListener() {
        
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    @MainThread
    public static StockLiveData get(String symbol) {
        if (sInstance == null) {
            sInstance = new StockLiveData(symbol);
        }
        return sInstance;
    }

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

    @Override
    protected void onActive() {
        mStockManager.requestPriceUpdates(mListener);
    }

    @Override
    protected void onInactive() {
        mStockManager.removeUpdates(mListener);
    }
}

你可以在片段中使用它，如下所示：

public class MyFragment extends Fragment {
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        StockLiveData.get(getActivity()).observe(this, price -> {
            // Update the UI.
        });
    }
}

多个片段和活动可以观察MyPriceListener实例。如果LiveData只有一个或多个可见并处于活动状态，则LiveData仅连接到系统服务。

转换LiveData

---

您可能希望在将LiveData对象存储在对象中之前对其进行更改 ，或者可能需要LiveData根据另一个对象的值返回不同的 实例。该 Lifecycle包提供了Transformations 包含支持这些场景的帮助器方法的 类。
Transformations.map()
对存储在LiveData对象中的值应用函数，并向下游传播结果。

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

Transformations.switchMap()
类似于map()，将函数应用于存储在LiveData 对象中的值，并展开并向下游发送结果。传递给的函数switchMap()必须返回一个LiveData对象，如下例所示：

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

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

您可以使用转换方法在观察者的生命周期中传递信息。除非观察者正在观察返回的LiveData对象，否则不会计算转换。由于转换是懒散计算的，因此与生命周期相关的行为会隐式传递，而不需要额外的显式调用或依赖关系。

如果你认为你需要一个Lifecycle对象内的 ViewModel对象，一个转换可能是一个更好的解决方案。例如，假设您有一个接受地址并返回该地址的邮政编码的UI组件。您可以ViewModel按照以下示例代码所示实现此组件的朴素：

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;

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

    private LiveData 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 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，因为该领域从未改变。该postalCode字段被定义为一个转换 addressInput，这意味着该repository.getPostCode()方法在addressInput更改时被调用。如果有一个活跃的观察者，如果在repository.getPostCode()被调用时没有活动的观察者，那么这是真实的，直到添加观察者才会进行计算。

该机制允许较低级别的应用创建LiveData按需延迟计算的对象。甲ViewModel对象可以容易地获得以引用LiveData的对象，然后在它们的顶部限定的变换规则。

创建新的转换

有十几种不同的特定转换可能在您的应用中很有用，但它们不是默认提供的。为了实现你自己的转换，你可以使用这个MediatorLiveData 类来监听其他LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。要了解更多关于这种模式的信息，请参阅Transformations 该类的参考文档 。

合并多个LiveData源

---

MediatorLiveData是LiveData允许您合并多个LiveData源的子类。MediatorLiveData 每当原始LiveData源对象发生更改时，都会触发对象的观察者。

例如，如果您LiveData的UI中有一个可以从本地数据库或网络更新的对象，则可以将以下源添加到该 MediatorLiveData对象：

• LiveData与存储在数据库中的数据关联的对象。
• LiveData与从网络访问的数据相关联的对象。

您的活动只需观察该MediatorLiveData对象即可从两个来源接收更新。有关详细示例，请参阅应用程序体系结构指南的附录：展示网络状态 部分。