关于android:Android-Jetpack架构组件四之LiveData

LiveData 是 Jetpack 架构组件 Lifecycle 库的一部分，是一个可感知生命周期的可察看容器类 (Observable)。与惯例的可察看类不同，LiveData 具备生命周期感知能力，这意味着它具备感知利用组件（如 Activity、Fragment 或 Service）的生命周期的能力，并且 LiveData 仅更新处于沉闷生命周期状态的利用组件观察者。

因而，LiveData 具备如下一些特效。

LiveData 是一个持有数据的容器类，它持有的数据是能够被观察者订阅的，当数据发生变化时会告诉观察者，观察者能够是 Activity、Fragment、Service 等对象。
LiveData 具备感知观察者的生命周期能力，并且只有当观察者处于激活状态（STARTED、RESUMED）才会接管到数据更新的告诉，在未激活时会主动解除注册观察者，以升高内存透露的危险。
应用 LiveData 保留数据时，因为数据和组件是拆散的，所以当组件被销毁时能够保证数据不会失落。

因而，咱们认为 LiveData 就是一个数据容器，它负责将数据包裹起来，使数据成为被观察者，当数据发生变化时，LiveData 会告诉观察者以便观察者做出响应。

那相比其余的一些观察者技术，如 RxJava 什么的，LiveData 有哪些劣势吗，上面是官网给出的一些长处列举。

确保 UI 界面始终和数据状态保持一致。
不会产生内存透露。观察者绑定到 Lifecycle 对象并在其相干生命周期 destroyed 后自行解除绑定。
不会因为 Activity 进行而产生奔溃。如 Activity 执行 finish 办法后，它就不会收到任何 LiveData 事件。
不再须要手动解决生命周期。UI 组件只需察看相干数据，不须要进行或复原察看，LiveData 会主动治理这些操作，因为 LiveData 能够感知生命周期状态的更改。
数据始终保持最新状态。在生命周期从非激活状态变为激活状态，始终保持最新数据，如后盾 Activity 在返回到前台后能够立刻收到数据的最新状态。
适当的配置更改。当配置产生更改（如屏幕旋转）而重建 Activity / Fragment，它会立刻收到最新的可用数据。
资源共享。LiveData 很适宜用于组件（Activity / Fragment）之间的通信，以及共享数据资源。

在 Jetpack 架构中，ViewModel 的次要作用是存储各种数据，当然，咱们也能够在 ViewModel 中解决一些数据逻辑。例如，咱们能够在 ViewModel 中对加载的数据进行某些加工操作。

而对页面来说，它并不需要关怀 ViewModel 中的数据逻辑，它只关怀须要展现的数据是什么，并且在数据发生变化时告诉页面数据的变动并做出相应的更新。而 LiveData 的作用就是包装 ViewModel 中数据，并让被观察者可能察看数据的变动。下图是官网 Jetpack 架构的示意图。

LiveData 的应用比较简单，次要会波及以下几个步骤：

创立 LiveData 实例以存储某种类型的数据，通常在 ViewModel 中实现。
定义一个具备 onChanged()办法的 Observer 对象，当 LiveData 持有数据发生变化时回调该办法。通常，咱们能够在 UI 控制器类中创立该 Observer 对象，如 Activity 或 Fragment。
通过应用 observe()办法将上述的 LiveData 对象和 Observer 对象关联在一起。这样 Observer 对象就与 LiveData 产生了订阅关系，当 LiveData 数据发生变化时告诉，而在 Observer 更新数据，所以 Observer 通常是 Activity 和 Fragment。

从上述步骤能够看出，LiveData 应用了观察者模式，观察者通常是 UI 控制器，如 Activity 或 Fragment，而被观察者则是 LiveData 包谷的数据对象，当 LiveData 对象持有数据发生变化，会告诉对它订阅的所有处于沉闷状态的订阅者。

LiveData 是一种可用于任何数据的封装容器，其中包含可实现 Collections 的对象，如 List。LiveData 对象通常存储在 ViewModel 对象中，并可通过 getter 办法进行拜访，如下所示。

public class NameViewModel extends ViewModel {

    private MutableLiveData<String> name;
    public MutableLiveData<String> getName() {if (name == null) {name = new MutableLiveData<String>();
        }
        return name;
    }
}

在大多数状况下，咱们能够利用组件的 onCreate() 办法中开始察看 LiveData 对象。并且，LiveData 仅在数据产生更改时才发送更新，并且仅发送给沉闷观察者，如下所示。

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private NameViewModel model;
    private TextView nameTV;

    @Override
    protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        nameTV=findViewById(R.id.nameTV);
        model = new ViewModelProvider(this).get(NameViewModel.class);
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {nameTV.setText(newName);
            }
        };
        model.getName().observe(this, nameObserver);
    }
}

当咱们传递 nameObserver 参数的状况下调用 observe() 后，零碎会立刻调用 onChanged()，从而提供 mCurrentName 中存储的最新值，如果 LiveData 对象尚未在 mCurrentName 中设置值，则不会调用 onChanged()。事实上，最简略的 LiveData 应用办法是 MutableLiveData，如下所示。

public class MainActivity extends AppCompatActivity {
   private static final String TAG="MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MutableLiveData<String> mutableLiveData  = new MutableLiveData<>();
        mutableLiveData.observe(this, new Observer<String>() { 
            @Override
            public void onChanged(@Nullable final String s) {Log.d(TAG, "onChanged:"+s);
            }
        });
        mutableLiveData.postValue("Android 利用开发实战");
    }
}

LiveData 自身没有公开可用的办法来更新存储的数据，如果须要批改 LiveData 的数据，能够应用 MutableLiveData 类将公开 setValue(T) 和 postValue(T) 办法。通常状况下会在 ViewModel 中应用 MutableLiveData，而后 ViewModel 只会向观察者公开不可变的 LiveData 对象，如下所示。

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

如果观察者的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于沉闷状态。以下示例代码阐明了如何扩大 LiveData 类。

    public class StockLiveData extends LiveData<BigDecimal> {
        private StockManager stockManager;

        private SimplePriceListener listener = new SimplePriceListener() {
            @Override
            public void onPriceChanged(BigDecimal price) {setValue(price);
            }
        };

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

        @Override
        protected void onActive() {stockManager.requestPriceUpdates(listener);
        }

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

在下面的示例中，咱们首先建设一个 StockLiveData 并继承自 LiveData，并重写了 onActive 和 onInactive 两个重要办法。

onActivite()：当有沉闷状态的订阅者订阅 LiveData 时会回调该办法，意味着须要在这里监听数据的变动。
onInactive()：当没有沉闷状态的订阅者订阅 LiveData 时会回调该办法，此时没有必要放弃 StockManage 服务象的连贯。
setValue()：留神到 value=price 这里是调用了 setValue(price)办法，通过该办法更新 LiveData 的值，进而告诉处于沉闷状态的订阅者。

此时，LiveData 会认为订阅者的生命周期处于 STARTED 或 RESUMED 状态时，该订阅者是沉闷的，那么如何应用 StockLiveData 类呢，如下所示。

    public class MyFragment extends Fragment {
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {super.onViewCreated(view, savedInstanceState);
            LiveData<BigDecimal> myPriceListener = ...;
            myPriceListener.observe(getViewLifeycleOwner(), price -> {// Update the UI.});
        }
    }

以 Fragment 作 LifecycleOwner 的实例传递到 observer()办法中，这样就将 Observer 绑定到领有生命周期的拥有者。因为 LiveData 能够在多个 Activity、Fragment 和 Service 中应用，所以能够创立单例模式。

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

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

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

        @Override
        protected void onActive() {stockManager.requestPriceUpdates(listener);
        }

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

而后，咱们就能够在 Fragment 中应用它，如下所示。

    public class MyFragment extends Fragment {
        @Override
        public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {super.onViewCreated(view, savedInstanceState);
            StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {// Update the UI.});
        }
    }

有时候，咱们心愿在把数据分发给观察者之前进行一些解决，或者返回一个基于已有值的 LiveData 对象的另外一个 LiveData 对象，此时就会用到 Transformations 类。转化 LiveData 时须要用到 Transformations.map()和 Transformations.switchMap()等办法。

Transformations.map()

例如，上面是应用 Transformations.map()办法解决 LiveData 存储的数据，而后将其传递给上游的示例代码。

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

Transformations.switchMap()

应用 Transformations.switchMap()办法同样能够扭转 LiveData 上游的后果，但传递给 switchMap()函数的必须是一个 LiveData 对象，如下所示。

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

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

不过，这种转换形式是惰性的，也就是只有 Observer 来订阅数据的时候，才会进行转换。因而，当在 ViewModel 中应用一个 Lifecycle 对象，这种转换是一种很好的解决方案。例如，假如您有一个界面组件，该组件承受地址并返回该地址的邮政编码，那么咱们能够应用 switchMap()办法进行转化。

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

通过后面的介绍，咱们晓得 LiveData 是一个可察看的数据持有者，并且它是具备组件生命周期感知能力的，那它是如何察看组件生命周期变动的呢？同时，LiveData 仅更新处于沉闷生命周期状态的利用组件观察者，也即是说 LiveData 并不会告诉所有的观察者，它只会告诉处于沉闷状态的观察者，那么它是如何做到这一点的呢？

后面介绍 LiveData 用法的时候提到，首先，咱们创立 LiveData 实例，而后调用 LiveData 的 observe 办法来注册观察者，将 ViewModel 和 LiveData 关联起来。observe()办法的源码如下。

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + "with different lifecycles");
        }
        if (existing != null) {return;}
        owner.getLifecycle().addObserver(wrapper);
    }

能够发现，observe 首先会判断组件以后的状态，如果状态为 DESTROYED，那么间接 return，这阐明 DESTROYED 状态的组件是不容许注册的。而后，新建一个 LifecycleBoundObserver 包装类，将 owner 和 observer 传了进去。接下来，将 observer 和 LifecycleBoundObserver 存储到 SafeIterableMap<Observer<? super T>, ObserverWrapper>mObservers 中，留神，此处应用的是 putIfAbsent 办法，接下来对传入的值进行判断，如果传入 key 对应的 value 曾经存在，就返回存在的 value，不进行替换，如果不存在就增加 key 和 value，返回 null。

最初，通过 owner.getLifecycle().addObserver() 办法将 LifecycleBoundObserver 增加到 Lifecycle 中实现注册，这样解决之后 LiveData 就有了察看组件生命周期变动的能力。

LifecycleBoundObservers 是 LiveData 的外部类，源码如下。

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {return mOwner == owner;}

        @Override
        void detachObserver() {mOwner.getLifecycle().removeObserver(this);
        }
    }

LifecycleBoundObserver 实现了 GenericLifecycleObserver 接口，当组件状态发生变化时，会调用 onStateChanged 办法，当组件处于 DESTROYED 状态时，会调用 removeObserver 办法移除 observer。

而 LifecycleBoundObserver 继承了 ObserverWrapper 类，须要重写 shouldBeActive 办法，用于判断以后传入的组件的状态是否是 Active 状态，即处于 STARTED 和 RESUMED 状态。

ObserverWrapper 是 Observer 的包装类，LiveData 的生命周期状态监听 activeStateChanged 办法就定义在抽象类 ObserverWrapper 中，源码如下。

private abstract class ObserverWrapper {
      final Observer<? super T> mObserver;
      boolean mActive;
      int mLastVersion = START_VERSION;

      ObserverWrapper(Observer<? super T> observer) {mObserver = observer;}

      abstract boolean shouldBeActive();

      boolean isAttachedTo(LifecycleOwner owner) {return false;}

      void detachObserver() {}

      void activeStateChanged(boolean newActive) {if (newActive == mActive) {return;}
          mActive = newActive;
          boolean wasInactive = LiveData.this.mActiveCount == 0;
          LiveData.this.mActiveCount += mActive ? 1 : -1;
          if (wasInactive && mActive) {onActive();
          }
          if (LiveData.this.mActiveCount == 0 && !mActive) {onInactive();
          }
          if (mActive) {dispatchingValue(this);
          }
      }
  }

activeStateChanged()办法会依据 Active 状态和处于 Active 状态的组件的数量，来对 onActive 办法和 onInactive 办法进行回调，咱们能够应用这两个办法拓展 LiveData 对象。如果生命周期状态是 Active 状态，那么会调用 dispatchingValue 办法。

private void dispatchingValue(@Nullable ObserverWrapper initiator) {if (mDispatchingValue) {
          mDispatchInvalidated = true;
          return;
      }
      mDispatchingValue = true;
      do {
          mDispatchInvalidated = false;
          if (initiator != null) {considerNotify(initiator);
              initiator = null;
          } else {
              for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                      mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {considerNotify(iterator.next().getValue());
                  if (mDispatchInvalidated) {break;}
              }
          }
      } while (mDispatchInvalidated);
      mDispatchingValue = false;
  }

mDispatchingValue 用于标记以后是否处于散发状态中，如果处于散发状态就会进行状态的散发，并最终调用 considerNotify 办法进行音讯的散发，代码如下所示。

private void considerNotify(ObserverWrapper observer) {if (!observer.mActive) {return;}
    if (!observer.shouldBeActive()) {observer.activeStateChanged(false); 
        return;
    }
    if (observer.mLastVersion >= mVersion) {return;}
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData); 
}

considerNotify 办法中做了屡次的判断，首先，判断 ObserverWrapper 的 mActive 值如果不为 true 就间接 return。而后，判断以后 observer 对应组件的状态是不是 Active，如果不是就会再次调用 activeStateChanged 办法并传入 false，其办法外部会再次判断是否执行 onActive 办法和 onInactive 办法回调。如果判断条件都满足就持续调用 Observer 的 onChanged 办法，这个办法正是应用 LiveData 的 observe 办法的回调。

关于android:Android-Jetpack架构组件四之LiveData

一、LiveData 简介

二、LiveData 与 ViewModel 的关系

三、LiveData 的根本应用

3.1 应用步骤

3.2 LiveData 应用示例

3.2.1 创立 LiveData 对象

3.2.2 察看 LiveData 对象

3.2.3 更新 LiveData 对象

3.2.4 扩大 LiveData

3.2.5 转换 LiveData

Transformations.map()

Transformations.switchMap()

四、LiveData 工作原理

LiveData 生命周期变动察看

LifecycleBoundObservers

ObserverWrapper