Lifecycle使用及实现机制分析

Android jectpack库之Lifecycle使用及实现机制分析

Lifecycle：生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。

一、Lifecycle使用

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        ...
    }
}

//在继承自ComponentActivity的activity中添加如下代码
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

二、Lifecycle实现机制概述

lifecycle 通过观察者模式，实现生命周期的状态的分发，在分发时利用状态模式，判断需要分发的观察者，然后通过反射获取对应观察者的注解信息，最后通过反射调用对应的处理函数

三、生命周期监听

3.1 ComponentActivity的生命周期监听

在activity中是通过给当前activity添加一个空白的Fragment（ReportFragment）来实现对activity的生命周期监听

protected void onCreate(@Nullable Bundle savedInstanceState) {
    mSavedStateRegistryController.performRestore(savedInstanceState);
    mContextAwareHelper.dispatchOnContextAvailable(this);
    super.onCreate(savedInstanceState);
    mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);
	//添加一个空白的Fragment（图片加载框架glide同理）用来监听activity的生命周期
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

接下来看ReportFragment的生命周期函数

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

//继续查看dispatch函数
private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
        // Only dispatch events from ReportFragment on API levels prior
        // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
        // added in ReportFragment.injectIfNeededIn
        dispatch(getActivity(), event);
    }
}
//继续跟踪
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }
    //重点跟踪这里
    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
        	 //不管是activity还是fragment，最终都是通过handleLifecycleEvent将生命周期的变化出去的 **
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

3.2 Fragment的生命周期监听

//初始化Lifecycle,在performCreate中调用mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);

private void initLifecycle() {
	//初始化LifecycleRegistry，在对应的生命周期中通过mLifecycleRegistry进行分发
    mLifecycleRegistry = new LifecycleRegistry(this);
    mSavedStateRegistryController = SavedStateRegistryController.create(this);
    mDefaultFactory = null;
}

void performStart() {
   ....
   //这里进行生命周期的分发
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    if (mView != null) {
        mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    mChildFragmentManager.dispatchStart();
}

四、添加观察者

添加观察者只需一行代码：

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

接下来开始分析LifecycleRegistry.addObserver()函数

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //重点关注这行代码，通过反射获取观察者中的生命周期对应处理函数
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
	...........
}

继续分析ObserverWithState

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
    	//重点关注这里
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }
}

继续分析Lifecycling.lifecycleEventObserver

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    .........
    return new ReflectiveGenericLifecycleObserver(object);
}

继续分析ReflectiveGenericLifecycleObserver

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        //这里通过反射获取wrapped（观察者）中对应的生命周期处理函数，保存在map中
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }
	
	//这里是声明周期发生变化以后，回调观察者的处理函数
    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}