Lifecycle的使用方式

自定义LifecycleObserver

// 1.自定义LifecycleObserver
class MLifecycleObserver : LifecycleObserver {

    // 2.在你想观察的生命周期中调用对应方法
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun loadData() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun cleanData() {

    }

}

// 3.注册观察者，观察宿主生命周期变化
class MFragment : Fragment() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val mLifecycleObserver = MLifecycleObserver()
        lifecycle.addObserver(mLifecycleObserver)
    }
}

LifecycleEventObserver

public interface LifecycleEventObserver extends LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}


class MLifecycleEventObserver : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        // TODO 接收到所有生命周期流程，拿自己想要的去做操作
        when (event) {
            Lifecycle.Event.ON_RESUME -> {
            }
            Lifecycle.Event.ON_DESTROY -> {
            }
        }
    }
}

FullLifecycleObserver

// 这个接口现在不开放了，不知道为啥
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);
}

class MLifecycleEventObserver : FullLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner?) {
        TODO("Not yet implemented")
    }

    override fun onDestroy(owner: LifecycleOwner?) {
        TODO("Not yet implemented")
    }
    
}

一些基础概念

LifecycleOwner接口（Lifecycle持有者）：实现该接口的getLifecycle方法，返回一个Lifecycle对象给外界使用，通过 Lifecycle.addObserver(LifecycleObserve) 添加观察者
LifecycleObserver接口（Lifecycle观察者） ：实现该接口，注册到LifecycleOwner宿主中，就可以观察到宿主的生命周期事件。
Lifecycle(能感知生命周期的对象) ：实现了LifecycleOwner接口的宿主，内部都需要生成一个Lifecycle供外界使用
State(当前宿主Lifecycle所处状态) ：有五种状态INITIALIZED，CREATED，STARTED，RESUMED，DESTROYED
Event(宿主生命周期方法对应) ：看作是宿主生命周期对应的事件
简单的关系图

fragment和activity如何使用Lifecycle

Fragment

这里只贴出关键部分，具体的可以自己看一下源码

首先Fragment 继承 LifecycleOwner，所以Fragment就是一个宿主对象，他的Lifecycle就是LifecycleRegistry，再用过handleLifecycleEvent去发送相应的生命周期事件

所以Fragment就是简单的在相应的生命周期流程内去调用Lifecycle的方法去分发事件

public class Fragment implements LifecycleOwner {
    mLifecycleRegistry = new LifecycleRegistry(this);
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }


    void performCreate(Bundle savedInstanceState) {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    

    void performStart() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    // TODO 每个生命周期都会调用performXXX
    //      mLifecycleRegistry就会去分发相应的事件
    void performXXX(){
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.XXX);
    }

}

Activity

简单的了解Fragment使用Lifecycle后，你是不是会认为Activity也是如出一辙？在各个生命周期中去分发事件？

和Fragment一样，都是使用LifecycleRegistry，所以分发生命周期事件也是handleLifecycleEvent

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

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

但是搜索了handleLifecycleEvent，在activity并没有找到使用的地方，

我想要调用handleLifecycleEvent，那就得拿到LifecycleRegistry，于是我搜索了一下Activity的getLifecycle()，最终定位到ReportFragment

最终我再ComponentActivity找到了他们之间的关系，在ComponentActivity中

protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    
}

所以接下来看看ReportFragment，可以看到它在Activity上添加了一个空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();
    }
}

在各个生命周期中调用dispatch，并把事件传入

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

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

@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
}

最终会调用到这里，这就拿到了activity.getLifecycle(),去分发handleLifecycleEvent

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }
}

LifecycleRegistry的分析

state 和 Event的关系

为了更好的理解，先用一张图理解一下State和Event的关系

用一张我以前保存的图，但是我不知道从哪里保存下来的了

addObserver，注册一个观察者的流程

我们知道调用了addObserver注册了观察者，我们就能接收到宿主完整的生命周期事件，所以我们直接从这个方法入手，看看它帮我们做了什么

注意：是完整的，也就是说在onresume注册，之前的oncreate，onstart也会接受到当然ondestory方法注册的话就不分发了。

我们来看看while循环的代码

注意：statefulObserver就是我们传入的observer，只不过是包装过的

while ((statefulObserver.mState.compareTo(targetState) < 0
        && mObserverMap.contains(observer))) {
        
    // TODO 调用包装类的分发事件
    statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
    
    // TODO 再次计算当前的目标状态
    targetState = calculateTargetState(observer);
}

假设我们再onResume方法注册一个观察者，用这种情况来分析，目标状态是RESUME

我们可以看到，用statefulObserver当前的状态是INITIALIZED

与目标状态作比较，是落后的，就是小于目标状态，所以while语句时会进入的

进入后看到statefulObserver.dispatchEvent()的变量upEvent，

通过状态State，会得到一个Event#ON_CREATE

再进入我们的observer包装类的方法 dispatchEvent

里面通过getStateAfter方法，用传入的Event事件，去获取需要前进到的状态

最后调用onStateChanged 方法将事件发送出去了

handleLifecycleEvent 宿主生命周期的流程

从前面的分析知道生命周期方法中，都会调用handleLifecycleEvent去分发事件

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // TODO 歌剧事件Event拿状态，与上面的一样的
    State next = getStateAfter(event);
    // 这个方法最终会调用到 sync() 方法
    moveToState(next);
}

moveToState(next)这个方法最终会调用到 sync() 方法，所以直接sync()

isSynced() 方法判断的是mObserverMap中所有观察者的状态是不是都同步到和宿主的状态一致

再来看第一个if条件，判断宿主和观察者的状态大小，宿主状态 < 观察者的状态 进入backwardPass，就比如前台切换到后台

里面的流程和前面分析的差不多，只不过用的是DownEvent，就是生命周期倒退的过程

第二个if条件，判断宿主和观察者的状态大小，宿主状态 > 观察者的状态 进入forwardPass

这个是生命周期前进的流程，所以用UpEvent

系统对三种不用的LifecycleObserver的处理

三种LifecycleObserver要实现的方法都不一样，但是dispatchEvent中最后都能调用lifecycleEventObserver的onStateChanged去分发，是怎么实现的

还记得addObserver中，将我们传入的observer包装成ObserverWithState

这里将我们传入的observer做了一个处理lifecycleEventObserver方法

所以进入lifecycleEventObserver方法看一下

可以看到针对不同类型的Observer创建相应的Adapter去适配

这里直接看一下FullLifecycleObserverAdapter

可以看出他是继承lifecycleEventObserver的，又重写了onStateChanged，所以dispatchEvent调用时就会进入这里，进而再去调用我们实现的方法

为什么自定义的LifecycleObserver的方法中加一个注解，就能在相应的生命周期事件调用到该方法的

从上面可以看到自定义的LifecycleObserver的处理，会有两种adapter，这是为什么

先看 ReflectiveGenericLifecycleObserver

他是通过反射去调用你自定义的LifecycleObserver的方法的

再看CompositeGeneratedAdaptersObserver

如果你引用了kapt androidx.lifecycle:lifecycle-compiler:2.0.0'注解处理器，那么注解处理器就会帮你生成对应的类，然后再 CompositeGeneratedAdaptersObserver 调用对应的方法

Android Lifecycle源码解读