Android架构组件（1）Lifecycles体系

前言

Android架构组件（Android Architecture Components，简称AAC），是 Android Jetpack的一部分。Jetpack是谷歌的一整套开发库，具体包括下图中的内容：

谷歌对于AAC的介绍是：

Android architecture components are a collection of libraries that help you design robust, testable, and maintainable apps. Start with classes for managing your UI component lifecycle and handling data persistence.

具体而言：

• Lifecycles： 用于更好的管理activity和fragment的生命周期。
• LiveData：用于构建响应式的可感知生命周期的数据流。
• ViewModel：用于独立于Android组件生命周期存储 UI 相关的数据。

此外AAC还包括其他的（比如Room）的很好用的库，但是我最感兴趣的就是这三个框架，因为LiveData提供了响应式框架（之前对响应式编程感兴趣而学习了一会儿RxJava,但是被复杂的API给劝退了，相较之下LiveData就很纯粹，搭建了响应式的架子，但没有Rx眼花缭乱的操作符）；ViewModel看起来也解决了我一直以来在Android组件之间传递数据的痛点，而Lifecycles给LiveData提供了感知生命周期的能力。

以下所有源码基于androidx.lifecycle库，库的版本为2.1.0；androidx.appcompat库，库的版本为1.1.0

Lifecycles 体系

Lifecycles提供了一种通过订阅者模式来监听Activity和Fragment的生命周期变化的方式。之前，我们解决这种需求的方法是在Activity和Fragment的生命周期方法 onXX 系列方法中直接嵌入功能代码或调用回调，现在通过Lifecycles来实现监听可以有效减少耦合，隔离功能代码。
Lifecycles框架中包括三个角色： Lifecycle、LifecycleOwner、LifecycleObserver，其中Lifecycle包含有关组件（例如Activity或Fragment）生命周期状态的信息，并允许其他对象观察此状态；LifecycleOwner表示一个拥有Lifecycle的类，LifecycleObserver则是LifecycleOwner的生命周期状态的监听者。

Lifecycle

Lifecycle使用两个枚举State，Event来表示其相关组件的状态和导致状态变化的事件，State包括5个值：DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED；Event包括7个值：ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY，它们的关系如图：

这个图里没有ON_ANY，这是因为ON_ANY代表发生了“任一事件”，而不是特定的一种事件。可以看到Event对应了Activity和Fragment的生命周期方法。每两个相邻状态之间的转换只有一种特定事件。每个事件也只会在两种特定状态之间发生，因此可以把它们视作一个有向图，每个State是一个节点，而每个Event则是一条边。
Lifecycle的接口如下：

public abstract class Lifecycle {

	@MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    public abstract State getCurrentState();
}

Lifecycle 声明了三个方法：分别用来注册、反注册订阅者，以及获取当前所处状态。这三个方法都加了@MainThread注解（表示该方法只应该在主线程中调用），因此可以猜测，Lifecycle不是线程安全的。

LifecycleOwner

LifecycleOwner 的接口如下：

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

很简单，就只有一个给LifecycleObserver获取Lifecycle的接口。

LifecycleObserver

LifecycleObserver的接口如下：

public interface LifecycleObserver {

}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

这是一个空接口，因为接受订阅事件的方法是需要通过OnLifecycleEvent注解添加，比如这样，onCreate方法会在ON_CREATE事件发生后调用：

 public static class TestObserver implements LifecycleObserver {
 
        @OnLifecycleEvent(Event.ON_CREATE)
        public void onCreate(LifecycleOwner owner) {
            Log.d(TAG, "onCreate:  " + owner.getLifecycle().getCurrentState());
        }
}

LifecycleObserver还有几个子类

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);
}

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    default void onCreate(LifecycleOwner owner) { }
    default void onStart(LifecycleOwner owner) { }
    default void onResume(LifecycleOwner owner) { }
    default void onPause(	LifecycleOwner owner) { }
    default void onStop(LifecycleOwner owner) { }
    default void onDestroy(LifecycleOwner owner) { }
}

创建LifecycleObserver一般可以通过直接继承LifecycleObserver或它的子类，但是使用DefaultLifecycleObserver需要使用Java1.8，因为它的实现用到了接口的default方法。

源码分析

Lifecycles 的接口以及看完了，接下来就来看它的实现，Lifecycles 的实现很明显是基于观察者模式的，并且观察者LifecycleObserver由我们自己实现，所以需要看的只由两部分：

1. LifecycleOwner（实际上就是Android support库中的Activity和Fragment）是怎么发布事件和更新状态的。
2. 注册和反注册，以及事件发布是如果管理的。

下面我就这两方面来看代码。

Activity 实现 LifecycleOwner

首先看Activity（androidx.appcompat.app.AppCompatActivity）的实现，LifecycleOwner接口的实现是在AppCompatActivity的父类ComponentActivity中，大概代码是下面这样（省略无关代码）：

public class ComponentActivity  implements LifecycleOwner {
	private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

	@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
    
	@Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }

}

这里面我只保留了两个类：LifecycleRegistry和ReportFragment，它们是何许人也呢？
LifecycleRegistry的接口如下，

public class LifecycleRegistry extends Lifecycle {

	@MainThread
    public void setCurrentState(@NonNull State state) {...}
   
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event){...}
   
    @Override
    public void addObserver(@NonNull LifecycleObserver observer){...}
  
    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {...}
   
    public int getObserverCount() {...}
    
    @Override
    public State getCurrentState() {...}
}

这个类的注释如下：

An implementation of Lifecycle that can handle multiple observers. It is used by Fragments and Support Library Activities. You can also directly use it if you have a custom LifecycleOwner.

由此可知，LifecycleRegistry就是我们要找的那个管理类，而ReportFragment，则是那个发布生命周期的类，ComponentActivity将发送事件的功能委托给了它。ReportFragment的方法大体如下：

public class ReportFragment extends Fragment {

	public static void injectIfNeededIn(Activity activity) {
	     android.app.FragmentManager manager = activity.getFragmentManager();
	     if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
	         manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
	         manager.executePendingTransactions();
	     }
	}
	
	@Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }
	
	private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

在Activity中调用的injectIfNeededIn方法里，ReportFragment检查了这个Activity有没有已经持有了ReportFragment ，如果没有就新增一个，这样ReportFragment就共享了该Activity的生命状态。然后在生命周期方法onXX方法中发送事件，发送的方式在dispatch方法里。也就是根据Activity的不同（实际上在我的这版代码里，LifecycleRegistryOwner已经被废弃了，因此实际上只会走activity instanceof LifecycleOwner这条线），调用getLifecycle获取Activity的Lifecycle（也就是LifecycleRegistry），然后调用它的handleLifecycleEvent方法，将事件发送出去。

Fragment 实现 LifecycleOwner

接下来看Fragment（androidx.fragment.app.Fragment）的实现了。其实Fragment的实现更简单，它直接实现了LifecycleOwner接口：

public class Fragment implements LifecycleOwner {
	LifecycleRegistry mLifecycleRegistry;

	public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
	private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
    	//...
    }
    
	void performCreate(Bundle savedInstanceState) {
	     //...
	     mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
	}
	
	void performPause() {
		//...
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }
}

Fragment同样是通过LifecycleRegistry来发送生命周期事件和管理订阅者的。

小结

通过上面的介绍，LIfecycles体系的大体样子已经描述出来了，Activity 和 Fragment 通过继承LifecycleOwner 来提供getLifecycle接口，但实际上Lifecycle的功能实现是由LifecycleRegistry来完成的；如果我们要监听组件的生命周期，则需要继承LifecycleObserver或它的子类，通过相应注解或者override方法来在生命周期变化时获取对应生命周期改变事件的回调。然后通过该组件的getLifecycle方法获取到它的Lifecycle，再调用Lifecycle的addObserver方法完成订阅者的注册，还要在合适的时机调用removeObserver完成反注册。同时要注意的是，LIfecycles的大部分接口都规定了在主线程调用，因此，这个框架并不是线程安全的。
可以看出LifecycleRegistry是LIfecycles框架最重要的一个类，因此，我会在下一节里用一整节的篇幅详细分析它的实现。