【Android Jetpack】- Lifecycles(源码

简介

用于感知Activity和Fragment生命周期。然后在不同生命周期执行不同的操作。

Activity中的Lifecycle源码分析

在Activity中我们可以这样添加Lifecycle监听

// 添加生命周期监听
lifecycle.addObserver(AJetpackLifecycleObserver())

Lifecycle监听类

class AJetpackLifecycleObserver : LifecycleObserver{
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connectListener() {}
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun disconnectListener() { }
}

lifecycle是一个LifecycleRegistry对象，源码中这样初始化的：

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

this是当前Activity实例，Activity实现了LifecycleOwner接口。

• Lifecycle实现监听的方式
  发现LifecycleRegistry初始化类SupportActivity的onCreate方法中有这样一行代码：

  ReportFragment.injectIfNeededIn(this);
  

  经常查看源码，没有发现在生命周期内调用LifecycleRegistry中的方法来发送生命周期事件。那么这里很可能Activity是使用了Fragment来监听的生命周期并发送事件。

  Activity又是在那里分发事件给Fragment的呢？通过阅读源码，发现在FragmentActivity类中各生命周期方法实现了生命周期事件的分发。比如：

  protected void onCreate(@Nullable Bundle savedInstanceState) {
      ...
      mFragments.dispatchCreate();
  }
  

  这里就是Fragment生命周期相关逻辑，感兴趣可以自己点进去看看，这里看一下ReportFragment类中的onActivityCreated方法，其它类似。

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

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

  这里调用到了LifecycleRegistry的handleLifecycleEvent方法。下面是核心部分：

    private void forwardPass(LifecycleOwner lifecycleOwner) {
        ...
                pushParentState(observer.mState);
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
         ...
    }
  
    private void backwardPass(LifecycleOwner lifecycleOwner) {
       ...
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
       ...
    }
  

  bserver.dispatchEvent(lifecycleOwner, event);

  static class ObserverWithState {
          ...
        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.getCallback(observer);
            mState = initialState;
        }
        void dispatchEvent(LifecycleOwner owner, Event event) {
            ...
            mLifecycleObserver.onStateChanged(owner, event);
            ...
        }
    }
  

  最后完成调用Lifecycle观察类方法全在Lifecycling类里。Lifecycling完成了对观察类中有@OnLifecycleEvent注解的方法解析到一个集合里面并且完成调用。

  Lifecycle.Event.ON_ANY所以生命周期都会调用含有该事件类型的方法。

Lifecycle更多用法

在上面分析过程，可以看到会调用这个方法getCallback,源码如下：

    static GenericLifecycleObserver getCallback(Object object) {
        // 监听所以生命周期方法
        if (object instanceof FullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
        }
        // 接收生命周期原始事件
        if (object instanceof GenericLifecycleObserver) {
            return (GenericLifecycleObserver) object;
        }

        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        if (type == GENERATED_CALLBACK) {
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
            for (int i = 0; i < constructors.size(); i++) {
                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
            }
            return new CompositeGeneratedAdaptersObserver(adapters);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }

这里分了两中回调方式，会创建不同的观察类，类型解析请自行查看源码。

• REFLECTIVE_CALLBACK = 1
• GENERATED_CALLBACK = 2

返回自己的LifecycleRegistry对象

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

总结

Lifecycles不仅仅支持上面以注解的方法监听生命周期，还可以自己定义接收生命周期回调的方式。并且对Service生命周期监听也做了支持，具体可以点看Lifecycles相关库查看。