Android Architecture Component之L

前言

系列文章

• Android Architecture Component之Lifecycle-Aware Components源码分析
• Android Architecture Component之LiveData源码分析
• Android Architecture Component之ViewModel源码分析

一、liveData是什么？

1.介绍

• LiveData是一个数据持有者类，他持有一个允许被观察的值，不同于普通的被观察者，liveData遵从应用程序的生命周期，被注册的观察者都要遵循其生命周期。
• 如果观察者的生命周期处于started或者resumed状态的时候，liveData认为观察者处于活动状态。
  LiveData只通知处于活跃状态的observer,不活跃的不通知其改变。

2. 优点

• 没有内存泄漏的风险，当页面销毁的时候，他们会自动被移除，不会导致内存溢出
• 不会因为activity的不可见导致crash。
  • 当Activity不可见的时候，即使有数据发生改变，LiveData也不同通知观察者，因为磁力的观察者的生命周期处于Started或者Resumed状态
• 配置的改变。
  • 当前的Activity配置发生改变（如屏幕方向，导致生命周期重新走了一遍，但是观察者们会恢复到变化前的数据。
• 资源共享
  • 我们的LiveData，只要连接系统服务一次就能支持所有的观察者。
• 不在手动处理生命周期
  • 生命周期组件，只需要在观察数据的时候观察数据即可，不需要理会生命周期，这一切就交给类liveData.
• 总是能获取最新的数据
  • 当Activity从后台进入前台的时候总共能够获取最新的数据。

二、用法简介

• 添加依赖

  compile "android.arch.lifecycle:runtime:1.0.3"
  compile "android.arch.lifecycle:extensions:1.0.0-rc1"
  annotationProcessor "android.arch.lifecycle:compiler:1.0.0-rc1"
  

• 创建一个LiveData的实例来保存特定类型的数据。 这通常在ViewModel类中完成。

  public class MainViewModel extends AndroidViewModel {
  private int i=10;
  
  private MutableLiveData<Student> studentMutableLiveData =new MutableLiveData<>();
  
  public MainViewModel(Application application) {
      super(application);
  }
  
  
  public void changeName(Student student) {
  
      student.setAge(i++);
      studentMutableLiveData.setValue(student);
  
  }
  
  public MutableLiveData<Student> getStudentMutableLiveData() {
      return studentMutableLiveData;
  }
  }
  

  MutableLiveData类公开公开setValue(T)和postValue(T)方法，如果需要编辑存储在LiveData对象中的值，则必须使用这些方法。 通常在ViewModel使用MutableLiveData ，然后ViewModel仅向观察者公开不可变的LiveData对象。
• 在Activity中

  ViewModelProvider of = ViewModelProviders.of(this);
     mainViewModel = of.get(MainViewModel.class);
     mainViewModel.getStudentMutableLiveData().observe(this, new Observer<Student>() {
         @Override
         public void onChanged(@Nullable Student student) {
  
  
         }
     });
     findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
  
             mainViewModel.changeName(mstudent);
  
         }
     });
  

  每次点击之后都会调用LiveData的setValue()方法，注册的观察者在onChanged()方法中就会收到更新后的我们观察的数据student.

三、源码分析

我们主要从三个方面讲解：怎么添加观察者？什么时候通知调用观察者，怎么移除观察者？怎么判定是liveData是活动活动状态？

1. 怎么添加观察者？

• 上面的列子用到了MutableLiveData，看下他的源码

  public class MutableLiveData<T> extends LiveData<T> {
  @Override
  public void postValue(T value) {
      super.postValue(value);
  }
  
  @Override
  public void setValue(T value) {
      super.setValue(value);
  }
  }
  

  很简单，继承了LiveData，提供了两个修改我们要观察数据的值。

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

• 从上面的列子中我们看到了MutableLiveData调用了observe()方法，这个方法是干什么用的呢？observer()继承于LiveData,所以我们看下LiveData的Observer()

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

  • LifecycleOwner在上面的列子中我们传入的是this,上篇我们说Lifecycle-Aware Components的时候我们知道activity实现了LifecycleOwner（继承了class SupportActivity extends Activity implements LifecycleOwner ）有个方法getLifecycle()返回了一个LifecycleRegistry的被观察者，它的主要作用是组件生命周期通知注册的观察者，做出改变。

  • 方法进来之后，首先获取LifecycleRegistry中当前组件的状态，如果处于destoryed，就什么也不做。

  • 如果不是destroyed就把我们的观察者封装成了LifecycleBoundObserver(),

  • 然后判断我们LiveData中的观察者mObservers集合中有咩有，没有的话就放入，有的话就返回空。

  • 如果没有的话也放入我们Activity组件中LifecycleRegistry中观察者集合中（这里面的观察者很杂，有观察数据的观察者（属于liveData）,也有我们上篇讲到到用注解自定义的观察者（处理与生命周期有关事件的））。

2. 什么时候通知观察者？

• 有人也可能会问为什么我们要把liveData中的观察者注册到LifecycleRegistry的handleLifecycleEvent()中，它自己不是有自己的观察者集合吗？

  这是因为在上篇我们将组件的生命周期事件分发的时候讲到过通过LifecycleRegistry的handleLifecycleEvent()方法，而它被通过Activity中的ReportFragment的各个生命周期方法调用，所以我们要把我们的观察者注册到LifecycleRegistry，交由它去负责生命周期事件分发给我们的观察者。

• 注册到LifecycleRegistry中的时候会被封装成ObserverWithState观察者，有生命周期事件的时候会调用ObserverWithState的dispatchEvent()

   ObserverWithState(LifecycleObserver observer, State initialState) {
          mLifecycleObserver = Lifecycling.getCallback(observer);
          mState = initialState;
      }
   void dispatchEvent(LifecycleOwner owner, Event event) {
              State newState = getStateAfter(event);
              mState = min(mState, newState);
              mLifecycleObserver.onStateChanged(owner, event);
              mState = newState;
          }
  

  其中传入的LifecycleObserver就是我们上面讲的LifecycleBoundObserver，我们看到代码中的dispatchEvent()，会调用onStateChanged，他怎么写的呢？

  @Override
          public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
              if (owner.getLifecycle().getCurrentState() == DESTROYED就一处，不是就通知改变) {
                  removeObserver(observer);
                  return;
              }
              // immediately set active state, so we'd never dispatch anything to inactive
              // owner
              activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
          }
  

  若果当前的LifecycleRegistry的状态是DESTROYED就移除我们的观察者，这就知道什么时候移除，我们也就不需要担心内存泄漏的风险。不是就通知改变，怎么通知观察者的呢？我们看下activeStateChanged，传入的参数我们后面会提到，先看下它的源码。

   if (active) {
              dispatchingValue(this);
          }
  

  如果处于活动状态就调用dispatchingValue()

  for (Iterator<Map.Entry<Observer<T>, LifecycleBoundObserver>> iterator =
                      mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                  for (Iterator<Map.Entry<Observer<T>, LifecycleBoundObserver>> iterator =
                      mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                  considerNotify(iterator.next().getValue());
                  if (mDispatchInvalidated) {
                      break;
                  }
              }(iterator.next().getValue());
                  if (mDispatchInvalidated) {
                      break;
                  }
              }
  

  在这里遍历liveData存放观察者的集合，然后considerNotify().看下源码

  observer.observer.onChanged()((T) mData);
  

  onChanged()方法就是我们在用法中最终回调的方法。

  我们总结一下过程：

  • liveData的observer()，把我们的观察者封装成了LifecycleBoundObserver，这个是liveData专用的观察者。
  • 添加到LiveData的观察者集合和Activity中的LifecycleRegistry的集合（负责生命周期分发，和获取当前activit状态）
  • 当Activity状态发生改变，就会通知我们的了LifecycleBoundObserver，同时调用它的onStateChanged()
  • 然后在调用activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
  • 然后遍历liveData的观察集合最后知道调用observer.observer.onChanged()((T) mData);

3. 怎么判断liveData是出于活跃状态？
   在文章的开头部分我们提到：

   如果观察者的生命周期处于started或者resumed状态的时候，liveData认为观察者处于活动状态。

   代码中怎么体现出来的呢？

• 在上面的带面中我们分析到了

  activeStateChanged(
  isActiveState(owner.getLifecycle().getCurrentState()));
  

  其中有个关键方法就是

  isActiveState(owner.getLifecycle().getCurrentState())
  

  看下它的源码

  static boolean isActiveState(State state) {
      return state.isAtLeast(STARTED);
  }
  

  关键点就在State，看下它的源码

  public enum State {
      /**
       * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
       * any more events. For instance, for an {@link android.app.Activity}, this state is reached
       * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
       */
      DESTROYED,
  
      /**
       * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
       * the state when it is constructed but has not received
       * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
       */
      INITIALIZED,
  
      /**
       * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
       * is reached in two cases:
       * <ul>
       *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
       *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
       * </ul>
       */
      CREATED,
  
      /**
       * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
       * is reached in two cases:
       * <ul>
       *     <li>after {@link android.app.Activity#onStart() onStart} call;
       *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
       * </ul>
       */
      STARTED,
  
      /**
       * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
       * is reached after {@link android.app.Activity#onResume() onResume} is called.
       */
      RESUMED;
  
      /**
       * Compares if this State is greater or equal to the given {@code state}.
       *
       * @param state State to compare with
       * @return true if this State is greater or equal to the given {@code state}
       */
      public boolean isAtLeast(@NonNull State state) {
          return compareTo(state) >= 0;
      }
  }
  

  对于isAtLeast()方法调用了枚举的compareTo，参数传入进来的是STARTED，大于等于就剩STARTED，RESUMED，所以我们说LiveData活动状态只有STARTED，RESUMED。