Jetpack - Lifecycle的使用和源码分析

Lifecycle的作用

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。

依赖

implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.0'

使用的demo

以前编写代码

class NoLifecycleActivity:AppCompatActivity() {

   private lateinit var mLocationListener: MyLocationListener

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       mLocationListener = MyLocationListener(this){ location ->
           //更新UI
       }
   }

   override fun onStart() {
       super.onStart()
       mLocationListener.start()
   }

   override fun onStop() {
       super.onStop()
       mLocationListener.stop()
   }

}

虽然功能实现了，但是太过于耦合了，真实的项目中会有太多管理界面和其他组件的调用，如果每个界面都管理多个组件的生命周期方法这会得它们难以维护，而且不利于后期的扩展。

lifecycle 提供的类和接口可帮助您以弹性和隔离的方式解决这些问题

Lifecycle

Lifecycle是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：

• 事件

  从框架和lifecycle类分派的生命周期事件，同时将事件映射到activity和fragment中的回调事件

• 状态

  由lifecycle对象跟踪组件的当前状态

  • INITIALIZED：对应Activity的onCreate之前的生命周期

  • DESTROYED：对应Activity的onDestroy

  • CREATED：对应Activity的onCreate到onStop之间的生命周期

  • STARTED：对应Activity的onStart到onPause之间的生命周期

  • RESUMED：对应Activity的onResume

使用lifecycle改装之后的demo

MyLocationListener改造类一下

class MyLocationListener(val context: Context,
                         val lifecycle: Lifecycle,
                         val call:(Location)->Unit):LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun start(){
        //开始定位
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop(){
        //停止
    }
}

activity变成

class UserLifecycleActivity:AppCompatActivity() {

    private lateinit var mLocationListener: MyLocationListener

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mLocationListener = MyLocationListener(this,lifecycle){ location ->
            //更新UI
        }
        lifecycle.addObserver(mLocationListener)
    }

}

使用 @OnLifecycleEvent 注解，在触发相应的生命周期的时候自动调用该方法，并且生命周期的处理都放到对应的组件中去了

Lifecycle原理分析

Lifecycle是在是一个接口，实现类是LifecycleRegistry，在ComponentActivity有对应的定义

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

State和Activity/Fragment的生命周期绑定

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

进入ReportFragment类中

public class ReportFragment extends android.app.Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            LifecycleCallbacks.registerIn(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();
        }
    }

    @SuppressWarnings("deprecation")
    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) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private ActivityInitializationListener mProcessListener;

    private void dispatchCreate(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

    private void dispatchStart(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onStart();
        }
    }

    private void dispatchResume(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onResume();
        }
    }

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

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

ComponentActivity添加了一个没有页面的ReportFragment，在ReportFragment的生命周期函数中，调用了LifecycleRegistry.handleLifecycleEvent() 方法来分发生命周期事件。

AppCompatActivity中添加了一个ReportFragment，其生命周期变化时，调用LifecycleRegistry.handleLifecycleEvent() 方法通知LifecycleRegistry改变状态，LifecycleRegistry内部调用moveToState() 改变状态，并调用每个LifecycleObserver.onStateChange() 方法通知生命周期变化。

addObserver方法分析

进入LifecycleRegistry类中查看addObserver 方法

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    //初始状态
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //封装Observer和initialState
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //将封装后的对象放入map中
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
   ...
    if (!isReentrance) {
        // 核心方法
        sync();
    }
   ...
}

进入ObserverWithState类中

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

进入lifecycleEventObserver方法

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    final Class<?> klass = object.getClass();
    //
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        //从map中获取klass相关集合
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            //创建对象
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            //将创建的对象传给SingleGeneratedAdapterObserver对象
            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);
}

通过反射创建对象

private static GeneratedAdapter createGeneratedAdapter(
        Constructor<? extends GeneratedAdapter> constructor, Object object) {
    //noinspection TryWithIdenticalCatches
    try {
        return constructor.newInstance(object);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    } catch (InstantiationException e) {
        throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
        throw new RuntimeException(e);
    }
}

SingleGeneratedAdapterObserver中有一个callMethods 当状态变化的时候就会调用。

class SingleGeneratedAdapterObserver implements LifecycleEventObserver {

    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

由此可见，Lifecycle 创建的 XXX_LifecycleAdapter 会包装成 SingleGeneratedAdapterObserver 或 CompositeGeneratedAdaptersObserver 对象，然后赋值给它的mLifecycleObserver 以便在 dispatchEvent 方法中通知相关的观察者

sync方法分析

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

主要是两个方法：

• backwardPass

  backwardPass 方法用于 “向后传递”，例如屏幕旋转或关闭页面的情况，在关闭页面之前的状态是 resume，那么关闭页面后，就要依次执行 onPause、onStop、onDestroy，对照上面的图来看，有一种 “往回走” 的感觉，所以叫做 backwardPass

• forwardPass

  forwardPass 方法用于 “向前传递”，比如打开一个新页面，会执行 onCreate、onStart、onResume，对照上面的图来看，就是一直往前走的感觉，所以叫做 forwardPass

backwardPass方法分析

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
   // 遍历map中的Observer 观察者
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = Event.downFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event down from " + observer.mState);
            }
            pushParentState(event.getTargetState());
            //触发生命周期回调的方法
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

获取事件对应的状态

@NonNull
public State getTargetState() {
    switch (this) {
        case ON_CREATE:
        case ON_STOP:
            return State.CREATED;
        case ON_START:
        case ON_PAUSE:
            return State.STARTED;
        case ON_RESUME:
            return State.RESUMED;
        case ON_DESTROY:
            return State.DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException(this + " has no target state");
}

forwardPass方法分析

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            final Event event = Event.upFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + observer.mState);
            }
            //触发生命周期回调的方法
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

小结