Jetpack: 生命感知组件 Lifecycle

酷的鑫
176 阅读3分钟

Jetpack: 生命感知组件 Lifecycle

这是我参与2022首次更文挑战的第4天，活动详情查看：2022首次更文挑战

前言

Lifecycle可谓是Jecpack组件的中流砥柱 ，所有的生命感知都与它有关 ，LiveData的自动解绑就是很关键的一个例子 。

Lifecycle有几个关键的类这里说一下:

  1. Lifecycle: 保存的生命周期的状态

    image.png

    图片来源

  2. LifecycleOwner: 接口类持有Lifecycle，带有生命感知的Activity和Fragment都实现了它

  3. ReportFragment: 一个空的Fragment，用来实现生命感知

  4. LifecycleEventObserver: 包装我们定义观察者的类

使用

定义一个接口，继承Observer

interface ILifecycleObserver: DefaultLifecycleObserver, LifecycleEventObserver {}

创建一个观察者的实现类 。

class ActivityLifecycleObserver: ILifecycleObserver {
    private var mTag = javaClass.simpleName
    override fun onCreate(owner: LifecycleOwner) {
        "onCreate ".logWithTag(mTag)
    }

    override fun onStart(owner: LifecycleOwner) {
        "onStart ".logWithTag(mTag)
    }

    override fun onResume(owner: LifecycleOwner) {
        "onResume ".logWithTag(mTag)
    }

    override fun onPause(owner: LifecycleOwner) {
        "onPause ".logWithTag(mTag)
    }

    override fun onStop(owner: LifecycleOwner) {
        "onStop ".logWithTag(mTag)
    }

    override fun onDestroy(owner: LifecycleOwner) {
        "onDestroy ".logWithTag(mTag)
    }

    override fun onStateChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
        event.name.logWithTag(mTag)
    }
}

fun String.logWithTag(tag: String) {
    Log.d(tag, this)
}

将观察者的实现类注册到lifecycle中 ，这样在生命周期发生变化的时候 ，通过通知观察者 ，就可以感受到对应的生命周期了 。

lifecycle.addObserver(ActivityLifecycleObserver())//1

原理

这里有一个问题：

是如何感知生命周期的 ？ 也就是lifecycle怎么知道Activity的生命周期的 。

我们来看看ComponentActivity这个类

//实现了LifecycleOwner
public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {

}

//其实就是一个简单的接口
public interface LifecycleOwner {
    @NonNull
    //获取Lifecycle接口
    Lifecycle getLifecycle();
}

既然要看生命周期 ，我们看看onCreate的时候做了什么

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

//也没什么就是把创建了一个ReportFragment 加入到Manager中
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();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

紧接着看Fragment的生命流程

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

有意思的事情出现了 ，每个方法都调用了 dispatch ，并且传入了对应的事件 Lifecycle.Event.xxx

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

紧接着我们看一下handleLifecycleEvent

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    //根据当前的Event返回对应的State
    State next = getStateAfter(event);
    moveToState(next);
}

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

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    //这里进行了分发
    sync();
    mHandlingEvent = false;
}

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);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        
        if (!mNewEventOccurred && newest != null
            && mState.compareTo(newest.getValue().mState) > 0) {
            //一般创建正常走这里 顺序创建
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

复杂的放在后面攻克 。我们先用百分之二十的努力攻克百分之80的问题 。

private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            //分发事件
            //upEvent 根据状态取出对应的事件 
            //1
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}


private static Event upEvent(State state) {
    switch (state) {
        case INITIALIZED:
        case DESTROYED:
            return ON_CREATE;
        case CREATED:
            return ON_START;
        case STARTED:
            return ON_RESUME;
        case RESUMED:
            throw new IllegalArgumentException();
    }
    throw new IllegalArgumentException("Unexpected state value " + state);
}

  1. 这个observer是一个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 = getStateAfter(event);
        mState = min(mState, newState);
        //真正的执行者是 LifecycleEventObserver
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

    那这个ObserverWithState是在哪里创建的呢 ？ 这个LifecycleEventObserver又是什么呢？

    上面都在分析 Observer的回调 ，现在我们回到最初的设置Observer的时候

    lifecycle.addObserver(ActivityLifecycleObserver())//1

    看看这个方法的内部

    public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //主角登场
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    //观察者数量自增
    mAddingObserverCounter++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

    我们可以看到 ObserverWithState的构造中传入了 observer ，这就是我们自定义的观察者 ，暂且定位mOB。

    ObserverWithState(LifecycleObserver observer, State initialState) {
    //将LifecycleObserver 传入到Lifecycling中包装成 LifecycleEventObserver
    mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
    mState = initialState;
}

    要是问为什么这么包装 ？ 大概是为了一致性吧 。

    我们看看lifecycleEventObserver

    static LifecycleEventObserver lifecycleEventObserver(Object object) {
    //是否继承自LifecycleEventObserver
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    //是否继承自FullLifecycleObserver
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        //都满足直接返回 FullLifecycleObserverAdapter
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    if (isFullLifecycleObserver) {
        //只满足FullLifecycleObserver 返回一个参数的FullLifecycleObserverAdapter
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    if (isLifecycleEventObserver) {
        //否则就直接返回LifecycleEventObserver 因为它本来就是
        return (LifecycleEventObserver) 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);
}

    上面有两种情况 ：

    • 非反射

    • 反射

    官方推荐是继承 DefaultLifecycleObserver的方式实现 ，注解的方式在Java8版本会废弃 。

    其实到这里一切都很清楚了 ，注册观察者 ，将其包装成 LifecycleEventObserver 放入ObserverWithState内部 ，内部通过空Fragment来对生命周期进行感应，然后回调对应的观察者通知 。

    整个过程中 Fragment 属于被观察者 ，借助LifecycleRegister来观察 ，自定义的Lifecycle属于观察者 。

总结

Lifecycle的原理 主要是创建了一个空页面的Fragment来对Activity的生命周期进行一个观察和处理 。

而且在最后也可以看出来 ，官方在尽量的少用反射 ，通过使用设计模式的方式来达到一个调用的目的 。

Lifecycle主要解决的问题有两个：

  • 我们可以以注册观察者的形式 统一对所有Activity的生命周期进行观察 。
  • 配合LiveDate来处理自动移除的操作 。

参考文章：

Lifecycle源码解析，让你一次学个够

文章中如果有问题的地方，欢迎大家多多评论指正，另外还是希望得到大家的点赞支持✨😉

avatar
文章
阅读
粉丝