Android JetPack LifeCycle源码分析

1,009 阅读1分钟

简介

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

官方对Lifecycle的定义非常简单,它的作用也很明确:存储具有生命周期的组件的生命周期状态,并且作为一个被观察者,允许其他组件保持对生命周期状态的观察。

Lifecycle组件的合理使用可赋予我们的代码显著的优点:

  • 无需在组件里生命周期方法里放置大量代码,即可实现对组件生命周期的监听的处理,再实现解耦的同时,让代码更有条理且精简易维护;
  • Lifecycle组件不会直接持有生命周期组件(Activity,Fragment等)的强引用,可以避免潜在的内存泄露问题。

这一点在ViewModeLiveData里有着完美的诠释,正是借助了Lifecycle它们才具备了生命周期感知的能力。

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    lifecycle.addObserver(object : LifecycleEventObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            Log.e("lifecycle","${event.name}")
        }
    })
}

在Activity里实现如上代码就能实现对Activity生命周期的监听,但是前提是该Activity的父类或者间接父类必须是ComponentActivity/AppCompatActivity或者其他实现了LifecycleOwner的类。

Lifecycle组件的角色

Lifecycle组件中有三个重要的组件:LifecycleOwner、LifecycleRegistry/Lifecycle和LifecycleObserver。它们分别扮演着生产者,管理者和消费者的角色。整个组件就是围绕着三个角色实现对生命周期的控制和调度的。LifecycleOwner负责发出生命周期,LifecycleRegistry负责存储和调度,LifecycleObserver通过和LifecycleRegistry绑定实现对生命周期的监听和消费。

  • LifecycleOwner:单一方法接口,表示实现该接口的类具有Lifecycle;
  • LifecycleRegistry:Lifecycle的子类,同时持有LifecycleOwner的弱引用和LifecycleObserver的强引用,起到了一个桥梁作用,本身是一个观察者的角色。LifecycleOwner将自己的生命周期状态存在LifecycleRegistry里面。每当LifecycleOwner的生命周期发生改变时,会通知LifecycleRegistry(当然,每个生命周期组件都持有LifecycleRegistry的实例),而LifecycleObserver通过观察者模式和LifecycleRegistry绑定实现对生命周期的观察;
  • LifecycleObserver:生命周期的观察者,本身是一个空接口,工作全部交由具体的实现类,只起到一个类型标记的作用。

它们的关系大致如下图所示:

image.png

LifecycleOwner

LifecycleOwner的定义很简单:

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

它是一个单一方法接口,用来标记实现类持有Lifecycle对象。getLifecycle方法返回一个Lifecycle,实际就是一个Lifecycle的实现类LifecycleRegistry的实例。AppCompatActivity、ComponentActivity和androidx.fragment.app.Fragment都实现了该接口。以ComponentActivity为例,LifeCycle在其中的实现如下:

public class ComponentActivity extends Activity implements LifecycleOwner {
        private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        
        public Lifecycle getLifecycle() {
                return mLifecycleRegistry;
        }
}

其目的很简单直接,就是为了向外部提供Lifecycle,也就是LifecycleRegistry的实例。

LifecycleRegistry/Lifecycle

LifecycleRegistry是LifeCycle的子类。它在整个组件中起到一个桥梁的作用,负责存储和分发生命周期的状态。整个组件正是通过它实现了解耦和数据传递的。

Lifecycle是一个抽象类,它定义了两个抽象方法addObserverremoveObserver用来添加和移除对生命周期进行监听的对象。这两个方法都由LifecycleRegistry实现。

另外还有两个表示生命周期的枚举类:

  • Event:生命周期改变时的事件,它由 Lifecycle(Activity)发出,和Activity、Fragment 中的回调事件对应。
  • State:组件的当前状态
public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY;
}

public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
}

注意这两个,看起来很像,关联性也很强。Event表示组件生命周期发生了改变时发生的状态,State表示当前组件处于的生命周期的某个状态。在Event枚举类中有如下方法:

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

可以总结出他们的关系如下:

image.png

Lifecycle本身作为一个抽象类起到的更多的是定义功能,它的行为实现基本都是通过LifecycleRegistry完成的:

public class LifecycleRegistry extends Lifecycle {


    //存储绑定的生命周期观察者
    //使用LifecycleObserver作为key值,使用ObserverWithState内部类作为value
    //ObserverWithState持有LifecycleObserver和State,前者是观察者的引用
    //State表示该观察者所持有的状态
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
    //组件当前的生命周期状态
    private State mState;
    
    //通过弱引用的方式持有LifecycleOwner(Activity/Fragment)
    private final WeakReference<LifecycleOwner> mLifecycleOwner;

    //正在进行绑定的观察者数量
    //用来标价正在通过addObserver进行绑定的观察者的数量
    private int mAddingObserverCounter = 0;

    //是否正在处理生命周期事件
    //mHandlingEvent为true时表示正在向外分生命周期状态
    private boolean mHandlingEvent = false;
    //标记有新事件发生
    private boolean mNewEventOccurred = false;

    //构造方法
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        this(provider, true);
    }

    private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
        mEnforceMainThread = enforceMainThread;
    }

    //根据当前的生命周期事件,设置当前的状态并通知观察者
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

    //开始处理状态
    private void moveToState(State next) {
        //如果当前状态和接收到的状态一致,那么直接返回不做任何处理
        if (mState == next) {
            return;
        }
        //修改当前的生命周期状态
        mState = next;
        //如果正在分发状态或者有观察者正在添加,则标记有新事件发生
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            return;
        }
        //标记正在处理事件
        mHandlingEvent = true;
        //开始同步生命周期状态
        sync();
        //还原标记
        mHandlingEvent = false;
    }

    private void sync() {
        //获取LifecycleOwner并确保不为空
        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;        
            //第一种是当前的状态值小于之前的状态,则执行回退状态的操作(如CREATED->RESUMED)
            //由于backwardPass是采用倒序迭代器对链表中的观察者一次进行迭代
            //所以这种情况下通过链表第一个元素进行状态比对
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }

            //第二种是当前的状态值大于之前的状态,则执行前进状态的操作(如>RESUMED->CREATED)
            //由于forwardPass是采用正序迭代器对链表中的观察者一次进行迭代
            //所以这种情况下通过链表最后一个元素进行状态比对
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

    //判断是否同步完成
    //通过判断mObserverMap的最eldest和newest的状态是否和当前状态一致
    //来判断是否是否将状态同步到了所有观察者
    //mObserverMap是一个FastSafeIterableMap类型的,它继承自SafeIterableMap
    //实现了类似LinkedHashMap的功能
    //其中eldest获取的是第一个被添加的元素,也就是第一个观察者
    //newest为最近一个别添加进来的元素也就是最后一个观察者
    //由于生命状态同步是通过FastSafeIterableMap中的迭代器一次实现的
    //所以当链表的头尾数据相同且都和当前状态保持一直,则可以认为它们同步完成了
    private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

    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一级一级的改变状态
            //如果观察者所处的状态和组件的最新状态跨等级,则一步一步的升级而不会跨状态提升
            //于此同时状态每次升级,观察者都会拿到一次回调
            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是一个ObserverWithState类型,它是LifecycleRegistry的静态内部类
                //它持有生命周期观察者的引用和它所处的状态
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
       //backwardPass除了采用倒序降级,其他地方与forwardPass逻辑基本一致。
        ...                
    }

    //增加新的LifecycleObserver观察者对象
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        //如果当前组件不处于DESTROYED状态,那么标记LifecycleObserver的初始状态为INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //创建ObserverWithState,为LifecycleObserver赋予状态
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //添加到容器mObserverMap中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        //如果previous不为null,表示重复添加,直接结束
        if (previous != null) {
            return;
        }

        //判断LifecycleOwner是否已经被销毁
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            return;
        }

        //判断是否是重入状态
        //例如在LifecycleObserver拿到回调之后又立即添加了监听
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        //计算状态
        State targetState = calculateTargetState(observer);
        //标记正在添加的LifecycleObserver的数量
        mAddingObserverCounter++;

        //通过一个while循环来将LifecycleObserver的状态设置为最新
        //设置的过程和forwardPass一致,逐级改变并且可能会多次触发回调
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            //分发事件,此处和forwardPass里的一致
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();
            targetState = calculateTargetState(observer);
        }

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

    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {
        //移除观察者LifecycleObserver
        mObserverMap.remove(observer);
    }


    //获取当前的生命周期状态
    public State getCurrentState() {
        return mState;
    }

    //封装LifecycleObserver和State
    //为LifecycleObserver增加状态
    //用来和组件的生命周期状态比对
    //以判定生命周期是否发生改变以及后续要执行的操作
    static class ObserverWithState {
        //观察者LifecycleObserver所处的状态
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
        	//处理LifecycleObserver,下文LifecycleObserver小节会讲到
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            //分发状态并修改LifecycleObserver最新的生命周期状态
            State newState = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
}

详细的逻辑已通过代码注释说明,但仍有几点要特别说明一下:

  1. LifecycleRegistry并不会直接持有LifecycleObserver,而是通过将LifecycleObserver作为Key值,使用ObserverWithState存储在FastSafeIterableMap中。ObserverWithState持有LifecycleObserver,并会持有一个生命周期状态,表示LifecycleObserver当前所收到的状态,用此状态和组件的生命周期状态进行比对,最终判断状态时升级还是降级或者维持不变;
  2. FastSafeIterableMap继承自SafeIterableMap,内部通过HashMap存储数据,但具备LinkedHashMap的特性,通过双向链表遍历数据,提供了正序和倒序两个迭代器;
  3. 每次添加LifecycleObserver的时候,都会为其绑定初始值State状态(如果组件当前状态不为DESTROYED状态默认为INITIALIZED),同时会与组件当前的状态进行比对,如果状态不同,则立刻触发状态分发机制,LifecycleObserver也会立刻收到回调。也就是LifecycleObserver在注册的时候就可能会立刻触发回调。
  4. 状态有两种改变方式,但是都是沿着顺序改变(DESTROYED;INITIALIZED;CREATED;CREATED;STARTED;RESUMED)一种是通过forwardPass进行升状态,只处理向RESUMED方向转化的状态,一种是backwardPass进行降状态,只处理向DESTROYED方向转化的状态。前者采用正序通知观察者回调,后者逆序。
  5. 状态时逐级分发调用的,不会跨级分发。状态改变后(或者添加监听时),相差多少级就会通过补发Event的方式触发多次分发以及回调。

关于第五点,使用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();
            }
        }
    }

注意里面的第二个while循环,它会不断比对ObserverWithState的状态(也就是LifecycleObserver的当前状态)和组件当前的生命周期状态。如果状态不匹配,则会通过Event.upFrom获取触发下一级状态的事件并进行补发。注意是下一级,而不是组件当前的状态(LifecycleRegistry.mState)。具体看一下upFrom方法:

public static Event upFrom(@NonNull State state) {
    switch (state) {
        case INITIALIZED:
            return ON_CREATE;
        case CREATED:
            return ON_START;
        case STARTED:
            return ON_RESUME;
        default:
            return null;
    }
}

注意我们传入的参数为observer.mState,也就是观察者LifecycleObserver当前的状态。紧接着forwardPass调用observer.dispatchEvent(lifecycleOwner, event);

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

可以发现,每次循环都只将状态改变一级,然后同过不断的循环直至状态同步。也就是当组件处于RESUMED状态时,而观察者LifecycleObserver处于INITIALIZED。则会触发三次回调,而三次的Event.name依次是ON_CREATE->ON_START->ON_RESUME。

同样的,在backwardPass中,采用的是Event.downFrom方式获取Event:

public static Event downFrom(@NonNull State state) {
    switch (state) {
        case CREATED:
            return ON_DESTROY;
        case STARTED:
            return ON_STOP;
        case RESUMED:
            return ON_PAUSE;
        default:
            return null;
    }
}

而且在绑定观察者的时候,就会立刻进行状态对比并同步。所以再添加监听的时候就有可能触发回调,当然它也遵守逐级改变状态的规则。所以再onCreate里写下面的代码:

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                Log.e("lifecycleOwnerState","${source.lifecycle.currentState}")
                Log.e("lifecycleEvent","${event.name}")
            }
        })
    }

输出如下:

E/lifecycleOwnerState: CREATED
E/lifecycleEvent: ON_CREATE
E/lifecycleOwnerState: STARTED
E/lifecycleEvent: ON_START
E/lifecycleOwnerState: RESUMED
E/lifecycleEvent: ON_RESUME

因为初始的状态为INITIALIZED,依次升级到RESUMED,回调发生了三次。而LifecycleOwner也就是Activity的状态已经是RESUMED了,所以每次都会取到它最新的状态。状态改变三次是发生在Observer的持有类ObserverWithState里的状态,也就是标记Observer的状态,就是ObserverWithState的成员变量mState。

LifecycleObserver

LifecycleObserver类是一个接口,它更多的起到类型或者身份标记的作用。它本身是一个空接口:

public interface LifecycleObserver {
}

所有的任务基本都靠它的具体实现类完成。它有以下几个直接的实现。每个都直接实现都有不同的其他实现。

LifecycleEventObserver是最简单的实现:只提供了onStateChanged方法用于获取事件和当前的状态。

public interface LifecycleEventObserver extends LifecycleObserver {
  onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

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

FullLifecycleObserver比较复杂,不再一股脑通过onStateChanged回调,而是对事件进行了拆分,根据不同的事件触发不同的方法。

而将事件进行区分的逻辑放在了LifecycleEventObserver的一个实现FullLifecycleObserverAdapter中:

class FullLifecycleObserverAdapter implements LifecycleEventObserver {

    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

FullLifecycleObserverAdapter本身也是个LifecycleEventObserver。可以用它对作为观察者进行绑定实现对生命周期事件的监听。而它重写了onStateChanged方法通过switch实现对事件的细化和区分,同时它持有FullLifecycleObserver和LifecycleEventObserver,可以按需对事件进行分发。

可能你会疑惑:LifecycleRegistry是如何区分这些观察者的具体类型的呢,毕竟它只提供了一个addObserver(LifecycleObserver)方法。答案就在LifecycleRegistry的内部类ObserverWithState中。在上文LifecycleRegistry的addObserver中,我们已经知道:LifecycleRegistry不会直接存储LifecycleObserver,而是通过ObserverWithState持有。它的构造方法如下:

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

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

mState上文已经解释过它是用来标记LifecycleObserver的状态的。重点看Lifecycling.lifecycleEventObserver(observer)这段代码。lifecycleEventObserver是Lifecycling的一个静态方法:

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    //判断Observer的类型
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;

    //如果Observer同时实现了LifecycleEventObserver和FullLifecycleObserver
    //通过FullLifecycleObserverAdapter包装它,并为FullLifecycleObserverAdapter的
    //两个变量fullLifecycleObserver和lifecycleEventObserver进行赋值。以便回调所有相关的方法。
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
            (LifecycleEventObserver) object);
    }

    //如果只实现了FullLifecycleObserver,进行包装,但为FullLifecycleObserverAdapter.lifecycleEventObserver
    //赋值为空。不进行它的回调
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }

    //LifecycleEventObserver类型,无需处理直接返回
    if (isLifecycleEventObserver) {
        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);
}

可以发现:在每次添加监听的时候,都会通过Lifecycling进行类型判断,从而确保LifecycleRegistry能正确触发不同观察者的回调事件。

另外,LifecycleEventObserver还有一个常用的实现:LifecycleBoundObserver。它是LiveData的内部类,正是它赋予了LiveData生命周期感知能力了。

事件的生产者

通过对LifeCycle的各个角色介绍,我们已经知道了生命周期事件分发和状态的流转处理方式了。LifecycleRegistry通过暴露handleLifecycleEvent方法接受事件,并进行后续处理。消费端的逻辑已经明确了。接下来就是寻找事件源了:也就是LifeCycle所处理的事件是如何产生的。

常见的生命周期事件生产者有Activity和Fragment。上文中讲到过,ComponentActivity实现LifecycleOwner接口,它就是一个能提供事件的生产者。但是它却不直接在自己的生命周期方法里低调用handleLifecycleEvent方法,而是通过ReportFragment进行。在它的onCreate方法里有如下代码:

 protected void onCreate(@Nullable Bundle savedInstanceState) {
    mSavedStateRegistryController.performRestore(savedInstanceState);
    mContextAwareHelper.dispatchOnContextAvailable(this);
    super.onCreate(savedInstanceState);
    mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

看一下ReportFragment.injectIfNeededIn做了什么:

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

injectIfNeededIn分了两种情况进行处理:

如果系统版本号>= 29,会向 Activity绑定一个LifecycleCallbacks ,直接进行生命周期监听。 LifecycleCallbacks.registerIn的部分代码如下:

 static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
    static void registerIn(Activity activity) {
        activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
    }

    @Override
    public void onActivityCreated(@NonNull Activity activity,
        @Nullable Bundle bundle) {
    }

    @Override
    public void onActivityPostCreated(@NonNull Activity activity,
        @Nullable Bundle savedInstanceState) {
        dispatch(activity, Lifecycle.Event.ON_CREATE);
    }
    .....

}

它实现了Application.ActivityLifecycleCallbacks接口,并向Activity进行了注册。

其中的dispatch方法实现如下:

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

就是在这里调用了LifecycleRegistry的handleLifecycleEvent方法,让他进行事件处理和分发。

而在Activity内,每当生命周期方法被触发。都会遍历ActivityLifecycleCallbacks然后进行回调。以onPause为例,相关代码如下:

private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
    new ArrayList<Application.ActivityLifecycleCallbacks>();

protected void onPause() {
    ...
    dispatchActivityPaused();
    ...
}

//分发事件
private void dispatchActivityPaused() {
    Object[] callbacks = collectActivityLifecycleCallbacks();
    if (callbacks != null) {
        for (int i = callbacks.length - 1; i >= 0; i--) {
            //遍历注册的对象,并依次触发
            ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPaused(this);
        }
    }
    getApplication().dispatchActivityPaused(this);
}

//返回所有的注册回调对象
private Object[] collectActivityLifecycleCallbacks() {
    Object[] callbacks = null;
    synchronized (mActivityLifecycleCallbacks) {
        if (mActivityLifecycleCallbacks.size() > 0) {
            callbacks = mActivityLifecycleCallbacks.toArray();
        }
    }
    return callbacks;
}

//添加callBack
public void registerActivityLifecycleCallbacks(
    @NonNull Application.ActivityLifecycleCallbacks callback) {
    synchronized (mActivityLifecycleCallbacks) {
        mActivityLifecycleCallbacks.add(callback);
    }
}

就是一个很简单的回调。

而对于系统版本号小于小于29的。则会向Activity添加一个无 UI 界面的ReportFragment实现监听,摘录一些ReportFragment的生命周期方法:

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

最终还是通过dispatch方法调用了LifecycleRegistry的handleLifecycleEvent方法,让他进行事件处理和分发。

只所以这样区分版本号,是registerActivityLifecycleCallbacks在Api 29时才被添加。

而在androidx.fragment.app.Fragment就简单粗暴的多了,已RESUME为例:

LifecycleRegistry mLifecycleRegistry;

public Fragment() {
    initLifecycle();
}

private void initLifecycle() {
    mLifecycleRegistry = new LifecycleRegistry(this);
    ...
}

public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

void performResume() {
    ...
    onResume();
    
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    ..
}

就是简单粗暴的在相关生命周期方法执行时直接通过LifecycleRegistry.handleLifecycleEvent发送事件。

相关扩展

LiveData和ViewModel是如何具备生命周期感知能力的呢,并在Activity生命周期结束时自行销毁的呢?

ViewModel的感知方式很简单,在ComponentActivity的构造方法有如下代码:

public ComponentActivity() {
    Lifecycle lifecycle = getLifecycle();

    getLifecycle().addObserver(new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
            if (event == Lifecycle.Event.ON_DESTROY) {
                    // Clear out the available context
                mContextAwareHelper.clearAvailableContext();
                    // And clear the ViewModelStore
                if (!isChangingConfigurations()) {
                    getViewModelStore().clear();
                }
            }
        }
    });

}

可以看到,正式通过LifeCycle实现对ON_DESTROY事件实行监听,然后ViewModelStore.clear方法从而达到销毁ViewModel的目的。

而LiveData则比较复杂一点,它通过一个LifecycleBoundObserver实现了对生命周期的监听。并重写了onStateChanged方法:

public void onStateChanged(@NonNull LifecycleOwner source,
    @NonNull Lifecycle.Event event) {
    Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
    if (currentState == DESTROYED) {
        removeObserver(mObserver);
        return;
    }
    Lifecycle.State prevState = null;
    while (prevState != currentState) {
        prevState = currentState;
        activeStateChanged(shouldBeActive());
        currentState = mOwner.getLifecycle().getCurrentState();
    }
}

可以看到:LiveData不仅会在DESTROYED进行解除绑定操作。还会进行判断,触发LiveData的回调。

这里只是简略的提了一下LiveData和ViewModel的生命周期处理,更过细节可结合LiveData源码解析ViewModel源码分析

Lifecycle还提供了ProcessLifecycleOwner实现对Application也就是应用程序的生命周期的监听。

只需要通过下面代码就可以实现监听:

class MainApplication : Application() {

    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                when(event){
                    Lifecycle.Event.ON_CREATE-> Log.e("event","App进程被创建")
                    Lifecycle.Event.ON_START-> Log.e("event","App进入到前台")
                    Lifecycle.Event.ON_RESUME-> Log.e("event","App进入到前台")
                    Lifecycle.Event.ON_PAUSE-> Log.e("event","App进入后台")
                    Lifecycle.Event.ON_STOP-> Log.e("event","App进入后台")
                    Lifecycle.Event.ON_DESTROY-> Log.e("event","系统不会分发,永远不会触发")
                }
            }
        })
    }
}

摘录ProcessLifecycleOwner关键代码如下:

public class ProcessLifecycleOwner implements LifecycleOwner {

    private Handler mHandler;
    private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
    private Runnable mDelayedPauseRunnable = new Runnable() {
        @Override
        public void run() {
            dispatchPauseIfNeeded();
            dispatchStopIfNeeded();
        }
    };

    ActivityInitializationListener mInitializationListener =
            new ActivityInitializationListener() {
                @Override
                public void onCreate() {
                }

                @Override
                public void onStart() {
                    activityStarted();
                }

                @Override
                public void onResume() {
                    activityResumed();
                }
            };

    private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();

   
    public static LifecycleOwner get() {
        return sInstance;
    }

    static void init(Context context) {
        sInstance.attach(context);
    }

    void activityStarted() {
        mStartedCounter++;
        if (mStartedCounter == 1 && mStopSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
            mStopSent = false;
        }
    }

    void activityResumed() {
       ...
    }

    void activityPaused() {
        ...
        mHandler.postDelayed(mDelayedPauseRunnable, TIMEOUT_MS);
    }

    void activityStopped() {
        dispatchStopIfNeeded();
    }

    void dispatchStopIfNeeded() {
        if (mStartedCounter == 0 && mPauseSent) {
            mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
            mStopSent = true;
        }
    }

    private ProcessLifecycleOwner() {
    }

    void attach(Context context) {
        mHandler = new Handler();
        mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
        Application app = (Application) context.getApplicationContext();
        app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
            @Override
            public void onActivityPreCreated(@NonNull Activity activity,
                    @Nullable Bundle savedInstanceState) {
.
                activity.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
                    @Override
                    public void onActivityPostStarted(@NonNull Activity activity) {
                        activityStarted();
                    }

                    @Override
                    public void onActivityPostResumed(@NonNull Activity activity) {
                        activityResumed();
                    }
                });
            }

            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
               
                if (Build.VERSION.SDK_INT < 29) {
                    ReportFragment.get(activity).setProcessListener(mInitializationListener);
                }
            }

            @Override
            public void onActivityPaused(Activity activity) {
                activityPaused();
            }

            @Override
            public void onActivityStopped(Activity activity) {
                activityStopped();
            }
        });
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mRegistry;
    }
}

可以总结以下几点:

  • ProcessLifecycleOwner通过Application.registerActivityLifecycleCallbacks来监听生命周期回调。
  • ProcessLifecycleOwner监听Application生命周期,并且不会触发ON_DESTROY;
  • ProcessLifecycleOwner使用可能使用Handler.postDelayed发动时间,会延时TIMEOUT_MS,也就是700毫秒。

接着就是ProcessLifecycleOwner的初始化分析了。

public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        LifecycleDispatcher.init(getContext());
        ProcessLifecycleOwner.init(getContext());
        return true;
    }

   ...
}

ProcessLifecycleOwner通过ProcessLifecycleOwnerInitializer进行初始化,它是一个ContentProvider。

而在LifeCycle会自动在AndroidManifest配置文件里注册它:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="androidx.lifecycle.process" >
    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="28" />
    <application>
        <provider
            android:name="androidx.lifecycle.ProcessLifecycleOwnerInitializer"
            android:authorities="${applicationId}.lifecycle-process"
            android:exported="false"
            android:multiprocess="true" />
    </application>
</manifest>

通过这种方式,LifeCycle可以实现无侵入的对Application进行监听。

总结

  • Activity和Fragment通过实现LifecycleOwner持有LifecycleRegistry的实例,并通过LifecycleRegistry进行生命周期事件的分发和处理;
  • LifecycleRegistry通过持有LifecycleOwner的弱引用来获取相关状态,同时避免可能发生的内存泄露;
  • LifecycleRegistry会按步骤分发事件,不可越级跳跃。存在级别差异的则会补发中间所有的事件;
  • ComponentActivity会根据系统版本号不同分别采取ReportFragment代发和Application.registerActivityLifecycleCallbacks回调两种方式分发事件。Fragment则是直接分发。