Lifecycle 源码初探

红太狼 2023-01-16 13:29 163阅读 0赞

# 前言 #

由于用法比较简单,所以本文不讲解基础使用,注重在源码的透彻分析上.  
基础使用文章:[Android 架构组件之 LifeCycle详解][Android _ LifeCycle]

一个小`Demo`:

public class MyObserver implements LifecycleObserver {
        
    
      private static final String TAG = "MyObserver";
    
      @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
      public void onCreate() {
        
        Log.e(TAG, "onCreate: ");
      }
    
      @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
      public void onPause() {
        
        Log.e(TAG, "onPause: ");
      }
     @OnLifecycleEvent(Lifecycle.Event.ON_START)
      public void onStart() {
        
        Log.e(TAG, "onStart: ");
      }
    
      @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
      public void onResume() {
        
        Log.e(TAG, "onResume: ");
      }
    
      @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
      public void onStop() {
        
        Log.e(TAG, "onStop: ");
      }
    
      @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
      public void onDestroy() {
        
        Log.e(TAG, "onDestroy: ");
      }
    }

class MainActivity : AppCompatActivity() {
        
    
      private val TAG = "MainActivity"
    
      override fun onCreate(savedInstanceState: Bundle?) {
        
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val myObserver = MyObserver()
        lifecycle.addObserver(myObserver)
        Log.e(TAG, "onCreate: ")
      }
    
      override fun onRestart() {
        
        super.onRestart()
        Log.e(TAG, "onRestart ")
      }
    
      override fun onStart() {
        
        super.onStart()
        Log.e(TAG, "onStart ")
      }
      override fun onResume() {
        
        super.onResume()
        Log.e(TAG, "onResume ")
      }
    
      override fun onStop() {
        
        super.onStop()
        Log.e(TAG, "onStop ")
      }
    
      override fun onDestroy() {
        
        super.onDestroy()
        Log.e(TAG, "onDestroy ")
      }
    
    }

# 源码讲解 #

`Lifecycle`有两个比较混淆的枚举常量

public abstract class Lifecycle {
        
    	 public enum Event {
        
          
            ON_CREATE,
           
            ON_START,
           
            ON_RESUME,
           
            ON_PAUSE,
           
            ON_STOP,
          
            ON_DESTROY,
           
            ON_ANY
        }
        public enum State {
        
          
            DESTROYED,
    
            /**
             * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
             * the state when it is constructed but has not received
             * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
             */
            INITIALIZED,
    
            /**
             * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
             * is reached in two cases:
             * <ul>
             *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
             *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
             * </ul>
             */
            CREATED,
    
            /**
             * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
             * is reached in two cases:
             * <ul>
             *     <li>after {@link android.app.Activity#onStart() onStart} call;
             *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
             * </ul>
             */
            STARTED,
    
            /**
             * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
             * is reached after {@link android.app.Activity#onResume() onResume} is called.
             */
            RESUMED;
    
            /**
             * Compares if this State is greater or equal to the given {@code state}.
             *
             * @param state State to compare with
             * @return true if this State is greater or equal to the given {@code state}
             */
            public boolean isAtLeast(@NonNull State state) {
        
                return compareTo(state) >= 0;
            }
        }
    }

你会看到`Event`和`State`,这里需要分清楚他们区别.

*  `Event`  
    和我们平常理解的`activity`生命周期是一致,而`ON_ANY`表示任意生命周期
 *  `State`  
    `lifecycle`内部使用的状态变量,可以利用进行`升级`或者`降级`计算得到是在对应`Event`哪个生命周期.  
    特别注意`CREATED`在`onStop`和`onCreate`都是`CREATED`状态.  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]

为了讲明`State` 我们举个例子,假设当前`activity`处于`oncreate`生命周期,那么当前状态就是`CREATED`,那么他升级就是`STARTED`状态(对应调用`onStart`),如果降级就是`DESTROYED` (对应调用`onDestry`).

--------------------

明白上面的基础知识我们开始看源码

`activity`的`lifecycle`实现为`ComponentActivity`

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
            LifecycleOwner{
        
            }

我看下接口声明

public interface LifecycleOwner {
        
        @NonNull
        Lifecycle getLifecycle();
    }

我们看下`ComponentActivity`如何实现此接口

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
            LifecycleOwner{
        
       
       // LifecycleRegistry是lifecycle库下一个默认实现
       private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
        public Lifecycle getLifecycle() {
        
            return mLifecycleRegistry;
        }
    }

我们从上可知道`ComponentActivity`主要实现依赖于`LifecycleRegistry`.这样的话我们也可以轻松实现一个`LifecycleOwner`.

public class LifecycleRegistry extends Lifecycle {
        
    	//当前状态
    	private State mState;
        //持有我们的activity
        private final WeakReference<LifecycleOwner> mLifecycleOwner;
    	//provider就是我们的activity
    	public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        
            mLifecycleOwner = new WeakReference<>(provider);
            mState = INITIALIZED;
        }
        //..略
    }

我们分析`lifecycle.addObserver(myObserver)`会发生什么.

public class LifecycleRegistry extends Lifecycle {
        
      //一个自定义map,可以在遍历的时候删除或者添加元素
      private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
                new FastSafeIterableMap<>();
    	            
    	@Override
        public void addObserver(@NonNull LifecycleObserver observer) {
        
        	//mState表示当前状态,mState在哪赋值我们先不用管
            State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        	//构造一个ObserverWithState包装类然后放入map结构.
            ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
            ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    		//如果之前有一个一样的观察者直接返回
            if (previous != null) {
        
                return;
            }
            //lifecycleOwner是我们的activity,被弱引用持有
            LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
            if (lifecycleOwner == null) {
        
                return;
            }
    		
            //略...
        }            
    
    }

上面我们知道我们的观察者被放入map集合中,在`activity`生命周期时必须回调所有map集合的生命周期函数.这个实现位于`ReportFragment`中,而`ComponentActivity`将这个fragment添加`fragmentmanager`中,在`ReportFragment`帮助分发事件.

//ComponentActivity.java
    public class ComponentActivity{
        
    	  protected void onCreate(@Nullable Bundle savedInstanceState) {
        
            
            ReportFragment.injectIfNeededIn(this);
          
        }
    }

public class ReportFragment extends Fragment {
        
        private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
                + ".LifecycleDispatcher.report_fragment_tag";
    
        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();
                // 这里是为了让ReportFragment被FragmentManager第一个执行
                manager.executePendingTransactions();
            }
        }

我们最后看下`ReportFragment`如何帮助我们分发

//ReportFragment.java
    public class ReportFragment extends Fragment {
        
    	 @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;
            }
    		//获取activity的lifecycle然后调用handleLifecycleEvent进行事件分发
            if (activity instanceof LifecycleOwner) {
        
                Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
                if (lifecycle instanceof LifecycleRegistry) {
        
                    ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
                }
            }
        }
    }

我们继续看看`LifecycleRegistry`如何处理分发

//LifecycleRegistry.java
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        
    		//getStateAfter将事件转化为状态(State)类
            State next = getStateAfter(event);
            moveToState(next);
        }
     static State getStateAfter(Event event) {
        
         switch (event) {
        
             case ON_CREATE:
             //注意onstop也是CREATED
             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;
            //如果当前已将在处理事件,只需要将mNewEventOccurred设置为true即可,内部会帮我们处理
            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();
            //如果activity被回收了那么不需要造作任何操作了
            if (lifecycleOwner == null) {
        
                throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                        + "garbage collected. It is too late to change lifecycle state.");
            }
            //视为true即可	
            while (!isSynced()) {
        
            	//用于标记在遍历分发事件时,新的事件发生了,比如
            	//在分发onstop事件,突然来了个onDestry
                mNewEventOccurred = false;
                
    
                //mObserverMap.eldest是我们最早放入集合的观察者,所以它的状态可能是最老的
                //如果mState是start,而eldest.mState是resume,那么这里小于0
                //backwardPass是用于降级的生命周期事件分发,
                if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
        
                    backwardPass(lifecycleOwner);
                }
                //获取mObserverMap最新放入的观察者
                Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
                //升级生命周期分发
                //比如当前是mState是resume,而newest.mState为start
                if (!mNewEventOccurred && newest != null
                        && mState.compareTo(newest.getValue().mState) > 0) {
        
                    forwardPass(lifecycleOwner);
                }
            
            }
            mNewEventOccurred = false;
        }

为方便理解我们先分析`forwardPass`

//LifecycleRegistry.java
    	//LifecycleOwner是我们的activity
        private void forwardPass(LifecycleOwner lifecycleOwner) {
        
        	//构造一个迭代器
            Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                    mObserverMap.iteratorWithAdditions();
            //mNewEventOccurred为true时表示有新的生命周周期        
            while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        
                
                Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
                
                ObserverWithState observer = entry.getValue();
            	//observer.mState.compareTo(mState) < 0确保生命周期时升序操作   
            	//mNewEventOccurred没有新事件发生
            	//mObserverMap.contains(entry.getKey())确保观察者还在集合里面.mObserverMap支持遍历时对集合操作
                while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                        && mObserverMap.contains(entry.getKey()))) {
        
                        
                    //分发事件,upEvent将状态升级得到对应的Event
                    observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                    
                }
            }
        }
          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);
        }

`backwardPass`源码:

//LifecycleRegistry.java
    
     private void backwardPass(LifecycleOwner lifecycleOwner) {
        
            
            Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                    mObserverMap.descendingIterator();
    		//mNewEventOccurred为true表示有新的生命周期事件在分发时被通知                
            while (descendingIterator.hasNext() && !mNewEventOccurred) {
        
                Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
                ObserverWithState observer = entry.getValue();
                //observer.mState.compareTo(mState) > 0确保是降级事件
                while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                        && mObserverMap.contains(entry.getKey()))) {
        
                
                	//将当前状态降级处理得到对应的event
                    Event event = downEvent(observer.mState);
                    //分发事件
                    observer.dispatchEvent(lifecycleOwner, event);
                    
                   
                }
            }
        }
        //生命周期下降
         private static Event downEvent(State state) {
        
            switch (state) {
        
                case INITIALIZED:
                    throw new IllegalArgumentException();
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                case DESTROYED:
                    throw new IllegalArgumentException();
            }
            throw new IllegalArgumentException("Unexpected state value " + state);
        }

不管是降级还是升级最后都是调用 `observer.dispatchEvent(lifecycleOwner, event);`我们最后看看他们是如何处理的.

我们的观察者会添加集合时被转化为`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);
                //将新状态赋值给成员属性保存.这里状态最小的:
                //比如新状态是CREATED,而之前状态是RESUMED,那么保存CREATED
                //比如新状态是RESUMED,而之前的状态是CREATED,那么保存CREATED
    			//我无法理解后续mstate和min(mState, newState)同时调用意义在哪里.如果知道还烦点播一下
                mState = min(mState, newState);
                //分发事件
                mLifecycleObserver.onStateChanged(owner, event);
                //将新事件赋值给mState
                mState = newState;
            }
        }

我们看下 `Lifecycling.lifecycleEventObserver`会生成什么类给我们

//Lifecycling.java
     
        static LifecycleEventObserver lifecycleEventObserver(Object object) {
        
            //可以继承LifecycleEventObserver来代替LifecycleObserver
            boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
            //可继承FullLifecycleObserver来代替LifecycleObserver
            boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
            //因为我们这里直接继承LifecycleObserver所以这里全部都是false
            //false
            if (isLifecycleEventObserver && isFullLifecycleObserver) {
        
                return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                        (LifecycleEventObserver) object);
            }
            //false
            if (isFullLifecycleObserver) {
        
                return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
            }
    		//false
            if (isLifecycleEventObserver) {
        
                return (LifecycleEventObserver) object;
            }
    
            final Class<?> klass = object.getClass();
            //内部会解析我们的注解,然后放入缓存中,方便ReflectiveGenericLifecycleObserver使用
            int type = getObserverConstructorType(klass);
            //false
            if (type == GENERATED_CALLBACK) {
        
               //略
            }
            //可见最后返回了一个ReflectiveGenericLifecycleObserver对象
            return new ReflectiveGenericLifecycleObserver(object);
        }

我们简单看下`getObserverConstructorType`即可.

//Lifecycling.java
      private static int getObserverConstructorType(Class<?> klass) {
        
            //第一次进入必然为null
            Integer callbackCache = sCallbackCache.get(klass);
            if (callbackCache != null) {
        
                return callbackCache;
            }
            //解析
            int type = resolveObserverCallbackType(klass);
            //放入缓存中
            sCallbackCache.put(klass, type);
            return type;
        }
        private static int resolveObserverCallbackType(Class<?> klass) {
        
            
            boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
            //这里返回true
            if (hasLifecycleMethods) {
        
                return REFLECTIVE_CALLBACK;
            }
        }

class ClassesInfoCache {
        
    	
        private final Map<Class, CallbackInfo> mCallbackMap = new HashMap<>();
        private final Map<Class, Boolean> mHasLifecycleMethods = new HashMap<>();
    	 boolean hasLifecycleMethods(Class klass) {
        
            Boolean hasLifecycleMethods = mHasLifecycleMethods.get(klass);
            if (hasLifecycleMethods != null) {
        
                return hasLifecycleMethods;
            }
    
            Method[] methods = getDeclaredMethods(klass);
            //遍历我们的所有方法,然后寻找是否存在OnLifecycleEvent注解
            for (Method method : methods) {
        
                OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
                if (annotation != null) {
        
                	//如果存在OnLifecycleEvent注解那么放入mCallbackMap集合中,CallbackInfo包含所有生命周期对应的回调函数.这里我们不在往下意义不是太大.
                	//同时mHasLifecycleMethods会放入true
                    createInfo(klass, methods);
                    return true;
                }
            }
            mHasLifecycleMethods.put(klass, false);
            return false;
        }
    
    }

缓存好生命周期对应的函数后返回`ReflectiveGenericLifecycleObserver`对象

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
        
        private final Object mWrapped;
        private final CallbackInfo mInfo;
    
        ReflectiveGenericLifecycleObserver(Object wrapped) {
        
            mWrapped = wrapped;
        	//mInfo缓存里每个event对应的回调函数
            mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
        }
    
        @Override
        public void onStateChanged(LifecycleOwner source, Event event) {
        
        	//内部有map集合对应event对应的method.调用invokeCallbacks将回调我们的观察者对应函数
            mInfo.invokeCallbacks(source, event, mWrapped);
        }
    }

[Android _ LifeCycle]: https://segmentfault.com/a/1190000015117758
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221022/b7fcb78ca8ac4cf0baf94b9dd40015d5.png