Android JetPack——Lifecycle

项目地址：项目地址包含之前的内容

public abstract class Lifecycle {}

根据文档的注释，这个类可以帮助我们创建一个拥有Android生命周期的对象。比如Fragment和Activity。
需要做到三点：

1. 生命周期拥有者，如Fragment、Activity、dialog、Service等，或者自己创建一个具有一定生命周期的class。
2. 生命周期的观察者，如请求数据的接口、动画等，或者自己创建一个需要跟随生命周期处理逻辑的class。
3. 生命周期的通知者，专门负责把生命周期的拥有者的不同生命阶段通知到生命周期观察者。

为了达到这三点，JetPack提供了三个类：

1. LifecycleOwner，实现此接口，即可作为生命周期的拥有者。
2. LifecycleObserver，实现此接口，即可作为生命周期的观察者。
3. Lifecycle，此抽象类用来管理观察者，LifecycleRegistry是它的一个具体实现，可以处理多个观察者。

ok，了解了上面的部分，就可以来实现一个简单的demo了。任何有规律的class，都可以有生命周期，看自己需求了，不止ac和Fragment

代码示例

1. 创建一个生命周期拥有者，需要实现LifecycleOwner接口
   这里就用一个Activity了,因为SupportActivity已经实现了LifecycleOwner

public class LifecycleActivity extends BaseActivity {

    public static void start(Context context) {
        Intent starter = new Intent(context, LifecycleActivity.class);
        context.startActivity(starter);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
    }
}

2. 创建一个生命周期观察者，需要实现LifecycleObserver接口

public class TestLifecycleObserver implements LifecycleObserver {
    final String TAG = getClass().getSimpleName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.i("life", TAG + "-----onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.i("life", TAG + "-----onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.i("life", TAG + "-----onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.i("life", TAG + "-----onPause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.i("life", TAG + "-----onStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.i("life", TAG + "-----onDestroy");
    }
}

TestLifecycleObserver 中创建了一些和Activity方法对应的生命周期，并且指定了对应的注解。管理者会根据注解决定回调哪个方法。

3. 创建生命周期管理者 ，就用系统已经实现的LifecycleRegistry。
   SupportActivity同样已经帮我处理好了

public class SupportActivity extends Activity implements LifecycleOwner, Component {
    private SimpleArrayMap<Class<? extends SupportActivity.ExtraData>, SupportActivity.ExtraData> mExtraDataMap = new SimpleArrayMap();
    //实例化LifecycleRegistry ，可以管理多个观察者
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
...
	protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //创建一个ReportFragment对象，主要目的是分发不同的状态
        ReportFragment.injectIfNeededIn(this);
    }

    @CallSuper
    protected void onSaveInstanceState(Bundle outState) {
    	//改变状态
        this.mLifecycleRegistry.markState(State.CREATED);
        super.onSaveInstanceState(outState);
    }

在onCreate的时候创建了一个ReportFragment对象，通过它的生命周期，来分发不同的生命事件。

public class ReportFragment extends Fragment {
...
@Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }
...
}

ReportFragment 把生命周期dispatch出去，接下来就是一系列的判断过程了，然后ReflectiveGenericLifecycleObserver中，利用反射，找到对应的方法去调用。

OK，经过上面三步，其实咱们只干了一步创建观察者，其它的都是已经实现好了的。接下来，只需要给Activity添加观察者就行了

 	@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //添加观察者
        getLifecycle().addObserver(new TestLifecycleObserver());
        setContentView(R.layout.activity_lifecycle);
    }

然后，运行看日志

07-12 10:49:00.967 11043-11043/com.example.study I/life: LifecycleActivity-----onCreate
07-12 10:49:00.987 11043-11043/com.example.study I/life: TestLifecycleObserver -----onCreate
07-12 10:49:00.987 11043-11043/com.example.study I/life: LifecycleActivity-----onStart
07-12 10:49:00.987 11043-11043/com.example.study I/life: TestLifecycleObserver -----onStart
07-12 10:49:00.987 11043-11043/com.example.study I/life: LifecycleActivity-----onResume
07-12 10:49:00.987 11043-11043/com.example.study I/life: TestLifecycleObserver -----onResume
---按下返回---
07-12 10:50:11.747 11043-11043/com.example.study I/life: TestLifecycleObserver -----onPause
07-12 10:50:11.747 11043-11043/com.example.study I/life: LifecycleActivity-----onPause
07-12 10:50:12.207 11043-11043/com.example.study I/life: TestLifecycleObserver -----onStop
07-12 10:50:12.207 11043-11043/com.example.study I/life: LifecycleActivity-----onStop
07-12 10:50:12.207 11043-11043/com.example.study I/life: TestLifecycleObserver -----onDestroy
07-12 10:50:12.207 11043-11043/com.example.study I/life: LifecycleActivity-----onDestroy

创建的时候TestLifecycleObserver 方法在前，退出的时候TestLifecycleObserver方法 在后。方便咱们做处理。