JetPack框架组件1————Lifecycle 使用及源码

悠悠 2022-10-14 12:50 197阅读 0赞

# JetPack框架组件1————Lifecycle 使用及源码 #

### 文章目录 ###

*  JetPack框架组件1————Lifecycle 使用及源码
 *   *   *  一.Lifecycle的使用
         *   *  1.lifecycle作用介绍
             *  2.实现LifecycleObserver
             *  3.注册LifecycleObserver
             *  4.自定义LifecycleOwner
             *  5.运行结果
         *  二.LifecycleObserver注册流程
         *  三.LifecycleOwner产生事件流程
         *  四.LifecycleRegister分发事件流程
         *  五.LifecycleObserver接收事件
         *   *  1.FullLifecycleObserverAdapter
             *  2.ReflectiveGenericLifecycleObserver
         *  六.源码类图
         *  七.参考资料

### 一.Lifecycle的使用 ###

#### 1.lifecycle作用介绍 ####

lifecycle是Android jetpact提供的组件之一。

它的功能概括来说就是:感知另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。可以将原本写在 Activity/Fragment生命周期回调代码，抽离出来。提高代码的可维护性。

原理是观察者模式:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDk5ODU5_size_16_color_FFFFFF_t_70]

观察者模型:

*  LifecycleObserver： 观察者
 *  LifecycleOwner ： 被观察者
 *  事件 ： LifecycleOwner的生命周期信息
 *  Lifecycle ：存储LifecycleOwner（如 Activity 或 Fragment）的生命周期状态的信息，并允许LifecycleObserver观察

所以和大多数的观察者模式一样，它的使用分为下面几步

1.  定义LifecycleObserver
2.  定义LifecycleOwner(Activity/Fragment默认实现)
3.  将LifecycleObserver注册在LifecycleOwner

#### 2.实现LifecycleObserver ####

实现LifecycleObserver,有两种方式一种是使用注解，一种使用回调

使用注解

class MyObserver : LifecycleObserver {
        
    
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun onResume() {
        
           Log.e("测试","ON_RESUME")
    
        }
    
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun onPause() {
        
            Log.e("测试","ON_PAUSE")
        }
    }

使用回调

class MyObserverV2 : DefaultLifecycleObserver {
        
    
        override fun onResume(owner: LifecycleOwner) {
        
            super.onResume(owner)
            Log.e("测试","onResume")
        }
    
        override fun onPause(owner: LifecycleOwner) {
        
            super.onPause(owner)
            Log.e("测试","onPause")
        }
        
    }

#### 3.注册LifecycleObserver ####

注册LifecycleObserver

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

如果是在Activity或Fragment可以直接调用Lifecycle

class MainActivity : AppCompatActivity() {
        
    
        override fun onCreate(savedInstanceState: Bundle?) {
        
            super.onCreate(savedInstanceState)
            lifecycle.addObserver(MyObserver())
        }
    
    }

#### 4.自定义LifecycleOwner ####

如果你不满足只监听Activity或Fragment，也可以自定义一个LifecycleOwner，同样可以让LifecycleObserver感知到

class MyLifecycleOwner : LifecycleOwner {
        
    
        private lateinit var lifecycleRegistry: LifecycleRegistry
    
        fun onCreate() {
        
            lifecycleRegistry = LifecycleRegistry(this)
            lifecycleRegistry.currentState = Lifecycle.State.CREATED
        }
    
        fun onStart() {
        
            lifecycleRegistry.currentState = Lifecycle.State.STARTED
        }
    
        override fun getLifecycle(): Lifecycle {
        
            return lifecycleRegistry
        }
    }

#### 5.运行结果 ####

![在这里插入图片描述][20210521145420147.png]

### 二.LifecycleObserver注册流程 ###

入口代码:

lifecycle.addObserver(MyObserver())

具体实现:  
lifecycle的实现类是LifecycleRegistry，直接看LifecycleRegistry中的代码  
LifecycleRegistry\#addObserver

class LifecycleRegistry{
        
        @Override
         public void addObserver(@NonNull LifecycleObserver observer) {
        
             enforceMainThreadIfNeeded("addObserver");
             State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
             ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
             //将statefulObserver放入map中
             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++;
             //如果statefulObserver保存状态 在 statefulObserver之前，这循环进行，并分发之间相差的事件
             //当保存的状态 == 当前的状态时，停止分发。
             //所以Lifecycle是一个粘性时间
             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);
                 }
                 statefulObserver.dispatchEvent(lifecycleOwner, event);
                 popParentState();
                 // mState / subling may have been changed recalculate
                 targetState = calculateTargetState(observer);
             }
     
             if (!isReentrance) {
        
                 // we do sync only on the top level.
                 sync();
             }
             mAddingObserverCounter--;
         }
    }

小结：

1.  在LifecycleRegistry注册流程中，将lifecycleOwner放入 mObserverMap
2.  在注册时，补齐之前没有分发的事件(粘性时间)

### 三.LifecycleOwner产生事件流程 ###

我们以activity为例，实现LifecycleOwner的ComponentActivity类，看看它的onCreate方法

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
            LifecycleOwner,
            ViewModelStoreOwner,
            SavedStateRegistryOwner,
            OnBackPressedDispatcherOwner {
        
       protected void onCreate(@Nullable Bundle savedInstanceState) {
        
            super.onCreate(savedInstanceState);
            mSavedStateRegistryController.performRestore(savedInstanceState);
            //ReportFragment做的代理
            ReportFragment.injectIfNeededIn(this);
            if (mContentLayoutId != 0) {
        
                setContentView(mContentLayoutId);
            }
        }
    }

再看看ReportFragment中的onCreate方法

public class ReportFragment extends Fragment {
        
        //....
        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
        
            super.onActivityCreated(savedInstanceState);
            dispatchCreate(mProcessListener);
            dispatch(Lifecycle.Event.ON_CREATE);
        }
    
        private void dispatch(@NonNull Lifecycle.Event event) {
        
            if (Build.VERSION.SDK_INT < 29) {
        
                dispatch(getActivity(), event);
            }
        }
        
        @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);
                }
            }
        }
      //....
    }

我们可以看到，最后实际上是在ReportFragment中通过lifecycle.handleLifecycleEvent方法进行了分发

再看一下Lifecycle.Event的类别，即看一下，看一下Lifecycle可以分发那些事件

public abstract class Lifecycle {
        
        @SuppressWarnings("WeakerAccess")
        public enum Event {
        
         
            ON_CREATE,
          
            ON_START,
            
            ON_RESUME,
          
            ON_PAUSE,
           
            ON_STOP,
           
            ON_DESTROY,
           
            ON_ANY
        }
    
        
        @SuppressWarnings("WeakerAccess")
        public enum State {
        
            
            DESTROYED,
    
            INITIALIZED,
    
            CREATED,
    
            STARTED,
    
            RESUMED;
    
            public boolean isAtLeast(@NonNull State state) {
        
                return compareTo(state) >= 0;
            }
        }
    }

state和event的区别  
![在这里插入图片描述][20210521155744345.png]  
小结:

1.  ComponentActivity最终通过ReportFragment分发了各种生命周期事件
2.  ReportFragment中通过lifecycle.handleLifecycleEvent方法进行了分发

### 四.LifecycleRegister分发事件流程 ###

上一节中，我们看到，最终LifecycleOwner通过调用lifecycle.handleLifecycleEvent方法进行了分发，这一节我们详细来看分发过程

public class LifecycleRegistry extends Lifecycle {
        
        public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        
            State next = getStateAfter(event);
            moveToState(next);
        }
        private void moveToState(State next) {
        
            //....
            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;
                    // no need to check eldest for nullability, because isSynced does it for us.
                    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;
        }
        private void backwardPass(LifecycleOwner lifecycleOwner) {
        
                Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                        mObserverMap.descendingIterator();
                while (descendingIterator.hasNext() && !mNewEventOccurred) {
        
                    Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
                    ObserverWithState observer = entry.getValue();
                    while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                            && mObserverMap.contains(entry.getKey()))) {
        
                        Event event = downEvent(observer.mState);
                        pushParentState(getStateAfter(event));
                        //这里处理分发，有注册那一节可知，observer实际上ObserverWithState类型，所以最后的处理在ObserverWithState中
                        observer.dispatchEvent(lifecycleOwner, event);
                        popParentState();
                    }
                }
            }
    }

ObserverWithState\#dispatchEvent  
ObserverWithState是一个内部静态类

static class ObserverWithState {
        
            State mState;
            LifecycleEventObserver mLifecycleObserver;
    
            ObserverWithState(LifecycleObserver observer, State initialState) {
        
                //获取mLifecycleObserver
                mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
                mState = initialState;
            }
    
            void dispatchEvent(LifecycleOwner owner, Event event) {
        
                State newState = getStateAfter(event);
                mState = min(mState, newState);
                //  这里进行分发
                mLifecycleObserver.onStateChanged(owner, event);
                mState = newState;
            }
        }

这里看看最终获取mLifecycleObserver的方法

public class Lifecycling {
        
        @NonNull
        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;
            }
            //通过反射。找到Lifecycle 自动生成的类 XXX_LifecycleAdapter
            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返回了4种LifecycleEventObserver:

*  FullLifecycleObserverAdapter
 *  SingleGeneratedAdapterObserver
 *  CompositeGeneratedAdaptersObserver
 *  ReflectiveGenericLifecycleObserver

下一节我们着重分析第一和第四，因为我们在开头的使用中注解和回调，分别对应的是FullLifecycleObserverAdapter和ReflectiveGenericLifecycleObserver

### 五.LifecycleObserver接收事件 ###

#### 1.FullLifecycleObserverAdapter ####

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:
                    //DefaultLifecycleObserver的父类是mFullLifecycleObserver
                    //所以这里面实质调用的是DefaultLifecycleObserver
                    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);
            }
        }
    }

#### 2.ReflectiveGenericLifecycleObserver ####

ReflectiveGenericLifecycleObserver这种情况下对应的就是，使用注解时调用

我们先看看@onLifecycleEvent的定义

@SuppressWarnings("unused")
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface OnLifecycleEvent {
        
        Lifecycle.Event value();
    }

注解参考文章  
[元注解的使用][Link 1]  
[注解的解析][Link 2]

所以我们要关注一下，在什么时候解析的OnLifecycleEvent

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
        
        private final Object mWrapped;
        private final CallbackInfo mInfo;
    
        ReflectiveGenericLifecycleObserver(Object wrapped) {
        
            mWrapped = wrapped;
            //mInfo的构造
            mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
        }
    
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        
            //事件分发
            mInfo.invokeCallbacks(source, event, mWrapped);
        }
    }

mInfo的构造:

class ClassesInfoCache {
        
        CallbackInfo getInfo(Class<?> klass) {
        
            CallbackInfo existing = mCallbackMap.get(klass);
            if (existing != null) {
        
                return existing;
            }
            existing = createInfo(klass, null);
            return existing;
        }
        private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
        
            ...
            //反射获取Methods list
            Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
            boolean hasLifecycleMethods = false;
            for (Method method : methods) {
        
                //获取OnLifecycleEvent注解
                OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
                if (annotation == null) {
        
                    continue;
                }
                ...
                //获取注解值
                Lifecycle.Event event = annotation.value();
                ...
    
                MethodReference methodReference = new MethodReference(callType, method);
                //将method和event放入handlerToEvent中
                verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
            }
            //mInfo的构造
            CallbackInfo info = new CallbackInfo(handlerToEvent);
            mCallbackMap.put(klass, info);
            mHasLifecycleMethods.put(klass, hasLifecycleMethods);
            return info;
        }
    
        private void verifyAndPutHandler(Map<MethodReference, Lifecycle.Event> handlers,
                MethodReference newHandler, Lifecycle.Event newEvent, Class<?> klass) {
        
            ...
            Lifecycle.Event event = handlers.get(newHandler);
            if (event == null) {
        
                //放入handlers中
                handlers.put(newHandler, newEvent);
            }
        }
    
        //mInfo的构造
        static class CallbackInfo {
        
            final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
            final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
    
            CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
        
                mHandlerToEvent = handlerToEvent;
                mEventToHandlers = new HashMap<>();
                for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
        
                    Lifecycle.Event event = entry.getValue();
                    List<MethodReference> methodReferences = mEventToHandlers.get(event);
                    if (methodReferences == null) {
        
                        methodReferences = new ArrayList<>();
                        //info中mEventToHandlers中保存的 event-method键值对
                        mEventToHandlers.put(event, methodReferences);
                    }
                    methodReferences.add(entry.getKey());
                }
            }
        }
    }

最后来看事件的分发

static class CallbackInfo {
        
            final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
            final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
    
            void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
        
                invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
                invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                        target);
            }
    
            private static void invokeMethodsForEvent(List<MethodReference> handlers,
                    LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
        
                if (handlers != null) {
        
                    for (int i = handlers.size() - 1; i >= 0; i--) {
        
                        //handle 是MethodReference类型
                        handlers.get(i).invokeCallback(source, event, mWrapped);
                    }
                }
            }
        }
    
        static class MethodReference {
        
            final int mCallType;
            final Method mMethod;
    
            void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
        
                //noinspection TryWithIdenticalCatches
                try {
        
                    switch (mCallType) {
        
                        case CALL_TYPE_NO_ARG:
                            mMethod.invoke(target);
                            break;
                        case CALL_TYPE_PROVIDER:
                            mMethod.invoke(target, source);
                            break;
                        case CALL_TYPE_PROVIDER_WITH_EVENT:
                            mMethod.invoke(target, source, event);
                            break;
                    }
                } catch (InvocationTargetException e) {
        
                    throw new RuntimeException("Failed to call observer method", e.getCause());
                } catch (IllegalAccessException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }

### 六.源码类图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDk5ODU5_size_16_color_FFFFFF_t_70 1]

### 七.参考资料 ###

[官方文档][Link 3]  
[Lifecycle 使用与源码分析——彻底搞懂Lifecycle原理][Lifecycle _Lifecycle]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDk5ODU5_size_16_color_FFFFFF_t_70]: /images/20221014/794eea4b815a4a3686934585da624150.png
[20210521145420147.png]: /images/20221014/cafdcd4a7c5c4a89aaa1e923b8d710ec.png
[20210521155744345.png]: /images/20221014/6348227e02354bcf8c880e24d58b1942.png
[Link 1]: https://www.liaoxuefeng.com/wiki/1252599548343744/1265102803921888
[Link 2]: https://www.liaoxuefeng.com/wiki/1252599548343744/1265102026065728
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDk5ODU5_size_16_color_FFFFFF_t_70 1]: /images/20221014/d891e2f35bb746cd91cc3a723d7faa33.png
[Link 3]: https://developer.android.google.cn/topic/libraries/architecture/lifecycle?hl=zh-cn
[Lifecycle _Lifecycle]: https://blog.csdn.net/xx326664162/article/details/90749168