Android-谷歌爸爸LifeCycle的簡單使用與簡單解析

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

完結撒花~

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發(fā)布,文章內容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容