一简介

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。一种常见的模式是在 Activity 和 Fragment 的生命周期方法中实现依赖组件的操作。但是，这种模式会导致代码条理性很差而且会扩散错误。通过使用生命周期感知型组件，您可以将依赖组件的代码从生命周期方法移入组件本身中。
androidx.lifecycle软件包提供了可用于构建生命周期感知型组件的类和接口 - 这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为
Lifecycle是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态

Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题
Livecycle 是一个表示android生命周期及状态的对象
LivecycleOwner 用于连接有生命周期的对象
LivecycleObserver 用于观察查LifecycleOwner

二应用

还是先介绍其使用然后再介绍其原理,这里举一个栗子 MVP 的小案例，如何使用Lifecycle 来实现具有生命周期感知的Presenter

App build.gradle 导入
dependencies {
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
}
需要监听的组件实现LifecycleObserver 接口
被观察组件(Activity/Fragment)添加被观察者注册

基于AppCompatActivity 都默认实现了LivecycleOwner 所以可以直接调用
getLifecycle().addObserver

public abstract class BasePresenter implements LifecycleObserver{
    public abstract void doSearch();
    public abstract void cancelSearch();
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreateX(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStartX(LifecycleOwner owner) {
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestory(LifecycleOwner owner) {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner) {
    }
}

public class OrdersPresenter extends BasePresenter {
    private OrdersModelImpl mOrdersModelImpl = null;
    private ISearchView mSearchView = null;
    private List<OrderListBean.DataBean> mList = null;
    public OrdersPresenter(final OrdersModelImpl ordersModelImpl,final 
    ISearchView searchView) {
        this.mOrdersModelImpl = ordersModelImpl;
        this.mSearchView = searchView;
        mList = new ArrayList<OrderListBean.DataBean>();
    }
    @Override
    public void doSearch() {
        mList = mOrdersModelImpl.getOrderList();
        mSearchView.showResult(mList);
    }
    @Override
    public void cancelSearch() {
        if(mList!=null)
            mList.clear();
        mSearchView.cancelShow(mList);
    }
    @Override
    void onCreateX(LifecycleOwner owner) {
        super.onCreateX(owner);
        Log.d("lhr",">>>>--onCreateX---");
    }

    @Override
    void onDestory(LifecycleOwner owner) {
        super.onDestory(owner);
        Log.d("lhr",">>>>--onDestory---");
    }
}
public class LifecycleActivity extends AppCompatActivity implements ISearchView, View.OnClickListener{
    private RecyclerView mRecyclerView;
    private DailyPagerAdapter mDailyPagerAdapter = null;
    private List<OrderListBean.DataBean> mArrayList = new 
    ArrayList<OrderListBean.DataBean>();
    private Button mSearchBtn = null;
    private Button mCancelBtn = null;
    private OrdersPresenter mIPresenterImpl = null;
    private OrdersModelImpl mOrdersModelImpl = null;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle);
        initView();
        mOrdersModelImpl = new OrdersModelImpl();
//        mIPresenterImpl = new IPresenterImpl(mOrdersModelImpl,this);
        mIPresenterImpl = new OrdersPresenter(mOrdersModelImpl,this);
        //生命周期绑定
        getLifecycle().addObserver(mIPresenterImpl);
    }
    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.btn_search:
                mIPresenterImpl.doSearch();
                break;
            case R.id.btn_search_cancel:
                mIPresenterImpl.cancelSearch();
                break;
        }

    }

    @Override
    public void showResult(List<OrderListBean.DataBean> datas) {
        if(null!=datas)
            setView(datas);
    }

    @Override
    public void cancelShow(List<OrderListBean.DataBean> datas) {
        if(null!=datas)
            setView(datas);
    }
    private void initView(){
        mRecyclerView = findViewById(R.id.pager_shopping_recycler);
        mSearchBtn = findViewById(R.id.btn_search);
        mCancelBtn = findViewById(R.id.btn_search_cancel);
        mSearchBtn.setOnClickListener(this);
        mCancelBtn.setOnClickListener(this);
        LinearLayoutManager layoutManager = new LinearLayoutManager(this);
        layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        mRecyclerView.setLayoutManager(layoutManager);

        mDailyPagerAdapter = new DailyPagerAdapter(this,mArrayList);
        mRecyclerView.setAdapter(mDailyPagerAdapter);
    }

    private void setView(List<OrderListBean.DataBean> mList){
        if(mArrayList!=null && mArrayList.size()!=0)
        mArrayList.clear();
        mArrayList.addAll(mList);
        mDailyPagerAdapter.notifyDataSetChanged();
    }
}

具体完整代码

三、生命周期状态如何同步到观察者

首先根据源码定位
AppCompatActivity ——>FragmentActivity——>ComponentActivity

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
        -------//此处省略N行代码

AppCompatActivity 实现了LifecycleOwner接口，同时持有实现了Lifecycle的LifecycleRegistry对象，这个对象就可以将其理解为观察者模式中的Observable，LifecycleRegistr聚合多个LifecycleObserver，生命周期改变时通知LifecycleObserver进行相应的方法调用。
AppCompatActivity 继承的extends androidx.core.app.ComponentActivity中的onCretae方法
ReportFragment.injectIfNeededIn(this);
就是在当前的Activity里添加一个无界面Fragment ReportFragment。

   @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

再看ReportFragment的生命周期函数
你会发现都调用了dispatch()方法，

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

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

而dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()
这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法。这种通过Fragment来感知Activity生命周期的方法其实在Glide的中也是有体现的。
回到handleLifecycleEvent方法中
State next = getStateAfter(event);

    static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

事件发生的时候，先得到当前activity应该出现的下一个状态

moveToState(next);
mState = next;更新现在的状态
sync();
backwardPass(lifecycleOwner);逆推
forwardPass(lifecycleOwner);正推
从图表上分析

lifecycle.png
forwardPass(lifecycleOwner)方法中的细节
ObserverWithState observer = entry.getValue();
找到ObserverWithState 类
调用mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
生成观察者适配器
接下来就是调用onStateChanged(),来通知实现了 LifecycleObserver的类，生命周期发生了变化
查看实现类
ReflectiveGenericLifecycleObserver。onStateChanged()
ReflectiveGenericLifecycleObserver。的构造方法中就把presenter中的方法和注解保存了下来再通过onStateChanged()进行生命周期的方法的调用

深入学习JetPack(一) Lifecycle

深入学习JetPack(一) Lifecycle

一简介

二应用

三、生命周期状态如何同步到观察者

深入学习JetPack(一) Lifecycle

一 简介

二 应用

三、生命周期状态如何同步到观察者

一简介

二应用