美文网首页Android开发Android开发经验谈Android开发
Android Jetpack 架构组件之 Lifecycle

Android Jetpack 架构组件之 Lifecycle

作者: Daybreaks | 来源:发表于2020-08-12 11:28 被阅读0次

    Lifecycle 实现原理分析


    所有源码基于Lifecycle最新版本 v2.2.0


    Lifecycle 的源码内容不多,非常轻量。

    Lifecycle 的核心设计模式就是观察者模式, 通过Lifecycle 的方法:addObserver(LifecycleObserver observer) 也可以看出来。

    一个非常有趣的地方是Lifecycle 观察到Activity的生命周期变化时机 是如何实现的。

    假设我们还没有看过源码,就来猜一下:

    当调用 LifecycleOwner 的方法 addObserver() 后,很容易想到 Lifecycle 使用了一种数据结构将 observer 存了起来,然后当 Activity 的生命周期变化时,lifecycle 遍历这个 observers集合 ,调用每一个 observer 的回调方法,这个回调方法中就是我们自己写的代码。这些都很容易想到,不容易想到的一点是 Lifecycle 如何准确得到生命周期变化的时机

    只能从源码中找到答案

    Lifecycle的源码大致分为两部分:

    • addObserver() 为视图控制器注册观察者
    • 监听生命周期的变化并通知观察者

    注册流程

    我们只需在视图控制器中调用 getLifecycle().addObserver(LifecycleObserver observer) 一行代码即可完成注册观察者功能。

    视图控制器:ActivityFragment 都实现了 LifecycleOwner,标志着他们是 具有Lifecylce的组件, 首先看一下LifecycleOwner 中的 getLifecycle():

    public Lifecycle getLifecycle()
    

    这个方法的返回类型为 Lifecycle 。 Lifecycle是一个抽象类:

    public abstract class Lifecycle {
    
        AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
       
        @MainThread
        public abstract void addObserver(@NonNull LifecycleObserver observer);
        @MainThread
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
        @MainThread
        public abstract State getCurrentState();
    
        @SuppressWarnings("WeakerAccess")
        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;
            public boolean isAtLeast(@NonNull State state) {
                return compareTo(state) >= 0;
            }
        }
    }
    

    Lifecycle 类中有三个方法、两个枚举。
    两个枚举定义了Lifecycle生命周期中的两个核心概念: 事件状态,这个在Android Jetpack 架构组件之 Lifecycle (二) 使用 已经详细说过了。
    三个方法:添加观察者、移除观察者、查询当前状态。也说明了 Lifecycle 类的主要功能

    • 添加观察者observer,将observer解析之后,存在集合中,并在适当的时候移除observer
    • 获取当前LifecycleOwner的状态,并负责状态与事件的转换

    Lifecycle是抽象类,唯一的具体实现类为 LifecycleRegistry

    public class ComponentActivity extends androidx.core.app.ComponentActivity implements
            LifecycleOwner,
            ViewModelStoreOwner,
            ... {
    
    
        private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // 重要
            ReportFragment.injectIfNeededIn(this);
            if (mContentLayoutId != 0) {
                setContentView(mContentLayoutId);
            }
        }
    
        public Lifecycle getLifecycle() {
            return mLifecycleRegistry;
        }
    }
    

    可以看到 LifecycleOwner 的方法 getLifecycle 在 Acitivity 中返回的正是LifecycleRegistry。

    首先介绍 LifecycleRegistry 类中的几个成员变量:

    public class LifecycleRegistry extends Lifecycle {
        /**
         * Current state
         */
        private State mState;
        private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
                new FastSafeIterableMap<>();
        private final WeakReference<LifecycleOwner> mLifecycleOwner;
        private int mAddingObserverCounter = 0;
        private boolean mHandlingEvent = false;
    }
    
    • FastSafeIterableMap LifecycleRegistry 中存储observer的集合类型,这个集合的功能是通过代理 HashMap 来进行拓展的。类似于 LinkedHashMap ,集合元素有序,通过链表将每一个Entry连起来。支持迭代操作和添加删除操作同时进行
    • mLifecycleOwner 这里使用了弱引用。如果在 Fragmnet 或者 Activitylifecycle 的引用被其他组件持有,弱引用保护了不会泄漏整个 FramgnetActivity (但是我们在开发中最好不要让 lifecycle 的引用暴露出来)
    • mAddingObserverCountermHandlingEvent 两个bool值,与同步操作相关。
    • mState 表示LifecycleOwner的当前状态。当lifecycle监测到Activity/Framgnet 的生命周期发生变化时,会首先更新mState的值,然后调用sync()这个方法将其他lifecycle的数据和observers的数据进行同步,并根据mState的变化分发mState对应Event

    我们接着分析注册流程

    addObserver(LifecycleObserver observer) 方法就是注册流程的入口。

        @Override
        public void addObserver(@NonNull LifecycleObserver observer) {
            State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
            // observer的转化流程在这里,这一步走完就已经将LifecycleObserver转换为LifecycleEventObserver了,
            ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
            ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
            // 重复添加,直接返回
            if (previous != null) {
                return;
            }
            // 判空
            LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
            if (lifecycleOwner == null) {
                return;
            }
    
            // 是否重入
            boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
            State targetState = calculateTargetState(observer);
            mAddingObserverCounter++;
            // 重要
            // 此时statefulObserver.mState 的初始值为 
            // INITIALIZED ,通过与计算出的 targetState 比较,
            // 小于的话,就进入循环。
            // (DESTROYED是最小的,INITIALIZED比DESTROYED大,CREATED比INITIALIZED,以此类推)
            while ((statefulObserver.mState.compareTo(targetState) < 0
                    && mObserverMap.contains(observer))) {
                // 将自身状态存起来
                pushParentState(statefulObserver.mState);
                // 分发Event
                statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
                // 将自身状态删掉
                popParentState();
                // 重新计算状态,用于循环退出条件:直到observer的状态从INITIALIZED的状态递进到当前LifecyleOwner的状态
                targetState = calculateTargetState(observer);
            }
            
            //如果重入的话没有必要每次都同步,浪费资源,只需要在最后一次处理完所有任务之后同步一次即可
            if (!isReentrance) {
                //更新一些属性,并分发event
                sync();
            }
            mAddingObserverCounter--;
        }
    

    这个方法首先进来前几行代码:将 stateobserver 包装成ObserverWithState类型,state 的初始值为 INITIALIZED ,然后存入集合,如果observer之前已经存在的话,就认定重复添加,直接返回。当添加的observer为新的时候,走下面流程。

    接着判断了一下isReentrance这个boolean值,从字面意思来看,代表着:是否重入,可以理解为:

    同时执行添加addObserver()的流程或者同时有其他Event事件正在分发

    如果重入的话,在方法末尾的同步方法sync()就不会执行,因为重入时对每一次状态改变都进行同步是多余的操作,只需要在最后一次进行同步操作即可。

    还记得上一篇文章的末尾我举了一个例子吗?在 observer 中观察 ActivityONSTART 事件和 ONCREATE 事件,而在 ActivityonResume() 中才调用 addObserver() 。结果 observer 还是能受到 nCreateonStart 生命周期的事件通知

    Lifecycle能实现这种神奇的操作,逻辑就在这一段while循环中。

    为了方便,while循环的分析写在了代码的注释里。

    看一下这段循环中涉及到的两个方法dispatchEvent()upEvent()

    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);
                    // observer的回调函数
                mLifecycleObserver.onStateChanged(owner, event);
                mState = newState;
            }
        }
    

    可以看到 dispatchEvent() 真正调用了 observer的回调方法,自己写的逻辑会在这里被执行,然后会更新mState,这里的 mState 是 observer 的 State。然后再配合 upEvent() 方法

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

    和上面的代码注释,大家应该能很容易理解:observer的 mState 初始状态为INITIALIZED ,然后通过upEvent不断向前分发事件,更新状态,直到 observer 的mState达到当前 LifecycleOwnermState

    一个完整的addObserver()流程就走完了

    LifecycleRegistry这个类整体的功能基本符合之前的猜测,这里再回顾一下

    • 添加观察者observer,将observer解析之后,存在集合中,并在适当的时候移除observer
    • 获取当前LifecycleOwner的状态,并负责状态与事件的转换

    在注册流程的最后,我其实漏了一个点,Lifecycle是如何将多种不同的LifecycleObserver实现类 转化成统一的LifecycleEventObserver实现类。

    因为对主线影响不大,这里就不展开说了,读者有兴趣可以自己去阅读源码,入口在addObserver()方法里,我已经用注释标出

    通知流程

    注册流程走完,Lifecycle 已经持有了所有 observer 的引用,只要在Activity \Fragment 生命周期改变的时候,通过Lifecycle 去通知所有observers,即可实现lifecycle的功能,而Lifecycle是如何感知Activity \Fragment生命周期的变化呢?

    其实之前看ComponentActivity类的时候有一个奇怪的东西:

    public class ComponentActivity extends androidx.core.app.ComponentActivity implements
            LifecycleOwner,
            ViewModelStoreOwner,
            ... {
                
            ...
    
        private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
        
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ...
            // 这里
            ReportFragment.injectIfNeededIn(this);
            if (mContentLayoutId != 0) {
                setContentView(mContentLayoutId);
            }
        }
            ...
      
        
    }
         
    

    跟进去看一下ReportFragment这个类有什么功能:

    public class ReportFragment extends Fragment {
        
    
        public static void injectIfNeededIn(Activity activity) {
            //为 @param activity 创建一个没有UI的Fragment
            android.app.FragmentManager manager = activity.getFragmentManager();
            if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
                manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
                manager.executePendingTransactions();
            }
        }
    
        ...
    
        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            dispatch(Lifecycle.Event.ON_CREATE);
        }
    
        @Override
        public void onStart() {
            dispatch(Lifecycle.Event.ON_START);
        }
    
        @Override
        public void onResume() {
            dispatch(Lifecycle.Event.ON_RESUME);
        }
    
        @Override
        public void onPause() {
            dispatch(Lifecycle.Event.ON_PAUSE);
        }
    
        @Override
        public void onStop() {
            dispatch(Lifecycle.Event.ON_STOP);
        }
    
        @Override
        public void onDestroy() {
            dispatch(Lifecycle.Event.ON_DESTROY);
        }
    
        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);
                }
            }
        }
        
    

    看完这里,豁然开朗。通过向 Activity 注入没有UI的一个 ReportFragment ,然后在** ReportFragment的每一个与 Activity 对应的生命周期回调中写了dispathch() 方法** 分发生命周期状态的改变.因为Fragment依赖于创建它的Activity,Fragment的生命周期和Activity生命周期同步,这样就间接实现了 Lifecycle 监听Activity生命周期的功能。然后看一下是dispatch()如何分发Event的:

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

    调用getActivity()后向上强制转换为LifecycleOwner,然后调用了LifecycleRegistry类的handleLifecycleEvent(),逻辑又回到了LifecycleRegistry类中,从这里将事件Event分发回LifecycleRegistry之中

    看一下handleLifecycleEvent(event)的具体实现:

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
            State next = getStateAfter(event);
            moveToState(next);
        }
    

    将分发来的事件Event转换为State,然后调用 moveToState() :

    private void moveToState(State next) {
           
            // 将 mState 更新为当前的 State
            mState = next;
                ...
            mHandlingEvent = true;
            sync();
            mHandlingEvent = false;
        }
    

    更新了mState的值之后,就调用sync()。这个方法算是 LifecycleRegistry 类中的一个很重要的方法。

    大家可以发现event事件分发过来之后只是更新了一下mSate的值,并没有去调用observers的 onStateChanged() 回调方法。

    所有的操作都是交给sync()方法根据 mState 的改变做出同步操作,并分发事件。

    private void sync() {
          LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
          ...
          // 判断是否需要同步,没有同步则一直进行
          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;
      }
    

    首先通过调用isSynced() 来判断是否需要同步,这个方法的实现非常简单。

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

    通过之前的介绍我们知道存储observer的这种数据结构一种有序的Map。

    这里通过比较第一个observer和最后一个observer,他们的 mState 值是否相等,相等的话则说明同步完毕,不相等的话继续同步,直到相等为止。

    第一个observer和最后一个observer的状态相等的话,中间所有的observer的mSate也一定是相等的,这样就标志的同步完成。

    forwardPass(lifecycleOwner)forwardPass(lifecycleOwner); 方法中,终于调用了心心念念的回调方法:onStateChanged(), 我们的代码在这里被执行。

    整个流程分析完毕。

    相关文章

      网友评论

        本文标题:Android Jetpack 架构组件之 Lifecycle

        本文链接:https://www.haomeiwen.com/subject/fyupdktx.html