LiveData概述，kotlin面试题

通常，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<String> nameObserver = new Observer<String>() {
            @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()调用nameObserverafter作为参数传递后，onChanged()立即调用，提供存储的最新值mCurrentName。如果LiveData对象未设置值mCurrentName，onChanged()则不调用。

2.3更新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对象。

2.3与房间一起使用LiveData

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

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

###三 扩展LiveData

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

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

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

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

您可以StockLiveData按如下方式使用该类：

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

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

如果Lifecycle对象未处于活动状态，则即使值发生更改，也不会调用观察者。

在之后Lifecycle的对象被破坏，观察者被自动删除。

LiveData对象具有生命周期感知这一事实意味着您可以在多个活动，片段和服务之间共享它们。为了使示例简单，您可以将LiveData类实现为单例，如下所示：

public class StockLiveData extends LiveData<BigDecimal> {
    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(symbol).observe(this, price -> {
            // Update the UI.
        });
    }
}

多个片段和活动可以观察MyPriceListener实例。LiveData仅在系统服务中的一个或多个可见且处于活动状态时才连接到系统服务。

###四 转换LiveData

您可能希望在将LiveData对象分发给观察者之前对其中存储的值进行更改，或者您可能需要

LiveData根据另一个实例的值返回其他实例。该Lifecycle包提供了Transformations包含支持这些方案的辅助方法的类。

对存储在LiveData对象中的值应用函数，并将结果传播到下游。

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

Transformations.switchMap()

类似于map()，将函数应用于存储在LiveData对象中的值，并向下游解包和调度结果。传递给的函数switchMap()必须返回一个LiveData对象，如下例所示

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

您可以使用转换方法在观察者的生命周期中传递信息。除非观察者正在观察返回的LiveData

对象，否则不会计算变换。因为转换是懒惰地计算的，所以与生命周期相关的行为被隐式传递而不需要额外的显式调用或依赖。

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

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

在这种情况下，postalCode字段是public和final，因为字段永远不会更改。该postalCode

字段被定义为转换addressInput，这意味着repository.getPostCode()在addressInput更改

时调用该方法。如果有一个活动的观察者，如果当时没有活动的观察者repository.getPostCode()

被调用，则这是真的，在添加观察者之前不进行任何计算。

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

4.1创建新的转换

在您的应用中有十几种不同的特定转换可能很有用，但默认情况下不提供它们。

要实现自己的转换，您可以使用MediatorLiveData该类，该类侦听其他LiveData

对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData

对象。要了解有关此模式的更多信息，请参阅Transformations该类的参考文档。

###五 合并多个LiveData源

MediatorLiveData是一个子类LiveData，允许您合并多个LiveData源。MediatorLiveData

只要任何原始LiveData源对象发生更改，就会触发对象的观察者。

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

1.LiveData与存储在数据库中的数据关联的对象。
2.LiveData与从网络访问的数据关联的对象。
您的活动只需要观察MediatorLiveData对象以从两个来源接收更新

手写事件通信方案LiveDataBus

https://pan.baidu.com/s/1S4Xjdw_cwYNsPL4SbP6tbA