lifeCycle如何使用？

1. 自定義一個類實現(xiàn)LifecycleObserver，在方法添加注解來監(jiān)控組件的生命周期狀態(tài)

    public class MyLifeListener implements LifecycleObserver {
   
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        void create(){ 
            Log.e("air", "create ");
        }
    
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        void stop() {
            Log.e("air", "destory ");
        }
    }
   

2.以activity為例，只需要getLifecycle().addObserver(new MyObserver())這么簡單的一句代碼，便可以完整的感知頁面的生命周期。emmm,我當前的support lib 26.1.0

    public class TestActivity extends AppCompatActivity {

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            getLifecycle().addObserver(new MyLifeListener());
        }

    }

求大佬輕噴，我只是來打醬油的原理分析

• support包26以上的SupportActivity和Fragment都默認實現(xiàn)了LifeCycleOwner接口。
  實現(xiàn)大體如以下代碼。26以下自定義的fragment和activity可以如此實現(xiàn)。

    public class MyFragment extends Fragment implements LifecycleOwner {
        LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
  
        @Override
        public LifecycleRegistry getLifecycle() {
            return lifecycleRegistry;
        }   
    }
  

• LifecycleRegistry實現(xiàn)了LifecycleOwner

  • 在其內部的addObServer方法中創(chuàng)建了ObserverWithState的實例statefulObserver,判斷如果狀態(tài)改變，調用dispatchEvent方法。;

      @Override
      public void addObserver(LifecycleObserver observer) {
          State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
          ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
          ....
    
          boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
          State targetState = calculateTargetState(observer);
          mAddingObserverCounter++;
          //如果狀態(tài)發(fā)生改變
          while ((statefulObserver.mState.compareTo(targetState) < 0
                  && mObserverMap.contains(observer))) {
              pushParentState(statefulObserver.mState);
              //發(fā)送事件
              statefulObserver.dispatchEvent(mLifecycleOwner, upEvent(statefulObserver.mState));
              popParentState();
              // mState / subling may have been changed recalculate
              targetState = calculateTargetState(observer);
          }
          if (!isReentrance) {
              // we do sync only on the top level.
              sync();
          }
          mAddingObserverCounter--;
    
       }
    

  • 那么ObserverWithState又做了什么呢?

      static class ObserverWithState {
          State mState;
          //GenericLifecycleObserver繼承LifecycleObserver的接口，內部提供了onStateChanged(LifecycleOwner source, Lifecycle.Event event)的抽象方法。
          GenericLifecycleObserver mLifecycleObserver;
    
          ObserverWithState(LifecycleObserver observer, State initialState) {
              //通過Lifecycling最終獲得ReflectiveGenericLifecycleObserver的實例。這個類實現(xiàn)了GenericLifecycleObserver接口。
              mLifecycleObserver = Lifecycling.getCallback(observer);
              mState = initialState;
          }
    
          void dispatchEvent(LifecycleOwner owner, Event event) {
              State newState = getStateAfter(event);
              mState = min(mState, newState);
              //調用該方法通知生命周期發(fā)生變化
              mLifecycleObserver.onStateChanged(owner, event);
              mState = newState;
          }
      }
    

    • Lifecycling如何創(chuàng)建的ReflectiveGenericLifecycleObserver？通過反射獲取該類的構造方法， 在getCallback的方法中傳入前面添加的LifeCycleObserver對象通過構造方法創(chuàng)建該類的實例對象。

        sREFLECTIVE = ReflectiveGenericLifecycleObserver.class.getDeclaredConstructor(Object.class);
      

  • ReflectiveGenericLifecycleObserver的構造方法中。

      ReflectiveGenericLifecycleObserver(Object wrapped) {
          //該對象為LifeCycleObserver的實例
          mWrapped = wrapped;
          mInfo = getInfo(mWrapped.getClass());
      }
    

    • 在getInfo中最終調用了

        private static CallbackInfo getInfo(Class klass) {
            CallbackInfo existing = sInfoCache.get(klass);
            if (existing != null) {
                return existing;
            }
            //調用了createInfo方法
            existing = createInfo(klass);
            return existing;
        }
      

    • creatInfo方法可以看出會一一遍歷對LifecycleObserver的實現(xiàn)類中加上@OnLifeCycleEvent的注解的方法，添加到CallbackInfo回調信息中

           private static CallbackInfo createInfo(Class klass) {
               Class superclass = klass.getSuperclass();
               ...
               Method[] methods = klass.getDeclaredMethods();
               ...
               for (Method method : methods) {
                   OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
                   if (annotation == null) {
                       continue;
                   }
                   ....
                   Event event = annotation.value();
                   MethodReference methodReference = new MethodReference(callType, method);
                   verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
               }
               CallbackInfo info = new CallbackInfo(handlerToEvent);
               sInfoCache.put(klass, info);
               return info;
       }
      

    • 在onStateChanged方法中最終根據(jù)回調信息執(zhí)行添加注解的方法。

        @Override
        public void onStateChanged(LifecycleOwner source, Event event) {
            invokeCallbacks(mInfo, source, event);
        }
      

完結撒花~