[[421728]]

前言

如何利用 android.arch.lifecycle 包提供的類來控制數(shù)據(jù)、監(jiān)聽器等的 lifecycle。同時(shí)，LiveData 與 ViewModel 的 lifecycle 也依賴于 Lifecycle 框架;

今天我們就來聊聊lifecycle的實(shí)現(xiàn)原理，來一波分析

一、為什么要引進(jìn)Lifecycle?

1、沒有引進(jìn)Lifecycle做法

• 在處理Activity或者Fragment組件的生命周期相關(guān)時(shí)，不可避免會遇到這樣的問題;
• 在Activity的onCreate()中初始化某些成員(比如MVP架構(gòu)中的Presenter，或者AudioManager、MediaPlayer等)，然后在onStop中對這些成員進(jìn)行對應(yīng)處理，在onDestroy中釋放這些資源，這樣導(dǎo)致我們的代碼也許會像這樣;

class MyPresenter{ 
    public MyPresenter() { 
    } 
    void create() { 
        //do something 
    } 
    void destroy() { 
        //do something 
    } 
} 
class MyActivity extends AppCompatActivity { 
    private MyPresenter presenter; 
    public void onCreate(...) { 
        presenter= new MyPresenter (); 
        presenter.create(); 
    } 
    public void onDestroy() { 
        super.onDestroy(); 
        presenter.destory(); 
    } 
} 

代碼沒有問題，關(guān)鍵問題是，實(shí)際生產(chǎn)環(huán)境中 ，這樣的代碼會非常復(fù)雜，你最終會有太多的類似調(diào)用并且會導(dǎo)致 onCreate() 和 onDestroy() 方法變的非常臃腫;

2、引進(jìn)Lifecycle做法

Lifecycle 是一個(gè)類，它持有關(guān)于組件(如 Activity 或 Fragment)生命周期狀態(tài)的信息，并且允許其他對象觀察此狀態(tài);

代碼如下：

Prestener繼承LifecycleObserver接口

public interface IPresenter extends LifecycleObserver { 
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) 
    void onCreate(@NotNull LifecycleOwner owner); 
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) 
    void onDestroy(@NotNull LifecycleOwner owner); 
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY) 
    void onLifecycleChanged(@NotNull LifecycleOwner owner, 
                            @NotNull Lifecycle.Event event); 
} 
public class BasePresenter implements IPresenter { 
    private static final String TAG = "com.qingmei2.module.base.BasePresenter";     
    @Override 
    public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) { 
    } 
    @Override 
    public void onCreate(@NotNull LifecycleOwner owner) { 
        Log.d("tag", "BasePresenter.onCreate" + this.getClass().toString()); 
    } 
    @Override 
    public void onDestroy(@NotNull LifecycleOwner owner) { 
        Log.d("tag", "BasePresenter.onDestroy" + this.getClass().toString()); 
    } 
} 

直接將我想要觀察到Presenter的生命周期事件都列了出來，然后封裝到BasePresenter 中，這樣每一個(gè)BasePresenter 的子類都能感知到Activity容器對應(yīng)的生命周期事件，并在子類重寫的方法中，對應(yīng)相應(yīng)行為

在Activity/Fragment容器中添加Observer

public class MainActivity extends AppCompatActivity { 
    private IPresenter mPresenter; 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        Log.d("tag", "onCreate" + this.getClass().toString()); 
        setContentView(R.layout.activity_main); 
        mPresenter = new MainPresenter(this); 
        getLifecycle().addObserver(mPresenter);//添加LifecycleObserver 
    } 
    @Override 
    protected void onDestroy() { 
        Log.d("tag", "onDestroy" + this.getClass().toString()); 
        super.onDestroy(); 
    } 
} 

每當(dāng)Activity發(fā)生了對應(yīng)的生命周期改變，Presenter就會執(zhí)行對應(yīng)事件注解的方法

二、Lifecycle原理層層深入分析

在Activity 獲取 Lifecycle，實(shí)際上是通過Activity的父類 ComponentActvitiy 獲取，父類實(shí)現(xiàn)了 LifecycleOwner 接口，就能獲取 Lifecycle ,最后注冊 LifecycleObserver 就能拿到生命周期回調(diào)了

1、 onCreate

在ComponentActvitiy的 onCreate 方法里面可以看到 ReportFragment 的創(chuàng)建。 
    /* ComponentActvitiy */ 
    @Override 
    protected void onCreate(@Nullable Bundle savedInstanceState) { 
        ... 
        ReportFragment.injectIfNeededIn(this); 
        ... 
    } 

2、 getLifecycle方法

/* ComponentActvitiy */ 
  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); 
  @NonNull 
  @Override 
  public Lifecycle getLifecycle() { 
      return mLifecycleRegistry; 
  } 
 Life 

3、 Lifecycle.Event

Lifecycle.Event 是個(gè)枚舉類，這里的生命周期 Event 并不是Fragment的，在后面的生命周期處理時(shí)會用上的。

public enum Event { 
     ON_CREATE, 
     ON_START, 
     ON_RESUME, 
     ON_PAUSE, 
     ON_STOP, 
     ON_DESTROY, 
     ON_ANY; 
    ... 
 } 

4、 ReportFragment的創(chuàng)建

ReportFragment 是一個(gè) 沒有界面的Fragment，如果有了解過Glide原理的同學(xué)，應(yīng)該也知道這個(gè)方法，就是通過看不見的Fragment，來感知生命周期，讓使用者無需考慮生命周期的問題。

在SDK29以上的版本 使用的是 LifecycleCallbacks.registerIn(activity)。

/* ReportFragment */ 
  public static void injectIfNeededIn(Activity activity) { 
      if (Build.VERSION.SDK_INT >= 29) { 
          // On API 29+, we can register for the correct Lifecycle callbacks directly 
          LifecycleCallbacks.registerIn(activity); 
      } 
      // Prior to API 29 and to maintain compatibility with older versions of 
      // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and 
      // need to support activities that don't extend from FragmentActivity from support lib), 
      // use a framework fragment to get the correct timing of Lifecycle events 
      android.app.FragmentManager manager = activity.getFragmentManager(); 
      if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) { 
          manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit(); 
          // Hopefully, we are the first to make a transaction. 
          manager.executePendingTransactions(); 
      } 
  } 

5、 LifecycleCallbacks.registerIn(activity)

LifecycleCallbacks 實(shí)現(xiàn)了 Application.ActivityLifecycleCallbacks接口，在SDK29以上的生命周期分發(fā)是由Application 分發(fā)的，activity注冊就能回調(diào)。

大名鼎鼎的LeakCanary在監(jiān)聽Activity生命周期，也是使用

Application.ActivityLifecycleCallbacks。 
    @RequiresApi(29) 
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks { 
        static void registerIn(Activity activity) { 
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks()); 
        } 
        ... 
        @Override 
        public void onActivityPostCreated(@NonNull Activity activity, 
                @Nullable Bundle savedInstanceState) { 
            dispatch(activity, Lifecycle.Event.ON_CREATE); 
        } 
      ... 
    } 

6、 ReportFragment.dispatch 版本兼容

如果SDK版本小于29，ReportFragment的各個(gè)生命周期方法里，會調(diào)用 dispatch 方法。

比如 onActivityCreated。

反正無論是使用 LifecycleCallbacks.registerIn(activity)，還是 Fragment 的生命周期回調(diào)，最后都會dispatch。

@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) { 
           // Only dispatch events from ReportFragment on API levels prior 
           // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks 
           // added in ReportFragment.injectIfNeededIn 
           dispatch(getActivity(), event); 
       } 
   } 
   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); 
           } 
       } 
   } 

7、 Lifecycle.State

State只有5個(gè)但是生命周期可是不止5個(gè)，所以Google他們設(shè)計(jì)時(shí)，就創(chuàng)建流程正著走，銷毀流程就反正走。

Lifecycle.State 
    /* Lifecycle.State */ 
    public enum State { 
        DESTROYED, 
        INITIALIZED, 
        CREATED, 
        STARTED, 
        RESUMED; 
        public boolean isAtLeast(@NonNull State state) { 
            return compareTo(state) >= 0; 
        } 
    } 

8、 handleLifecycleEvent

LifecycleRegistryOwner 也是繼承 LifecycleOwner，所以他們最后都會執(zhí)行 LifecycleRegistry 的 handleLifecycleEvent 方法。

就是把 Lifecycle.Event處理一下，轉(zhuǎn)化成 Lifecycle.State

/* Lifecycle.Event */ 
      @NonNull 
      public State getTargetState() { 
          switch (this) { 
              case ON_CREATE: 
              case ON_STOP: 
                  return State.CREATED; 
              case ON_START: 
              case ON_PAUSE: 
                  return State.STARTED; 
              case ON_RESUME: 
                  return State.RESUMED; 
              case ON_DESTROY: 
                  return State.DESTROYED; 
              case ON_ANY: 
                  break; 
          } 
          throw new IllegalArgumentException(this + " has no target state"); 
      } 
Lifecycle.State 繼續(xù)往下傳，先用 mState 保存，再 sync 方法處理。 
  /* LifecycleRegistry  */ 
  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { 
      enforceMainThreadIfNeeded("handleLifecycleEvent"); 
      moveToState(event.getTargetState()); 
  } 
  private void moveToState(State next) { 
      if (mState == next) { 
          return; 
      } 
      //保存state狀態(tài) 
      mState = next; 
      if (mHandlingEvent || mAddingObserverCounter != 0) { 
          mNewEventOccurred = true; 
          // we will figure out what to do on upper level. 
          return; 
      } 
      mHandlingEvent = true; 
      sync(); 
      mHandlingEvent = false; 
  } 

9、 sync

這里利用上一個(gè)方法保存的mState，用于比較，判斷是正向執(zhí)行還是反向執(zhí)行生命周期

/* LifecycleRegistry  */ 
   private void sync() { 
       //這是弱引用包裝過的LifecycleOwner  
       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. 
           //上一個(gè)方法保存的mState，跟組件之前的的mState對比 
           if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) { 
               //返向執(zhí)行流程 
               backwardPass(lifecycleOwner); 
           } 
           Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); 
           if (!mNewEventOccurred && newest != null 
                   && mState.compareTo(newest.getValue().mState) > 0) { 
               //正向執(zhí)行流程 
               forwardPass(lifecycleOwner); 
           } 
       } 
       mNewEventOccurred = false; 
   } 

10、 forwardPass

反向的邏輯差不多，只是執(zhí)行 backwardPass ，先轉(zhuǎn)換Stata，最后執(zhí)行 observer.dispatchEvent。

這里又把 Lifecycle.State 轉(zhuǎn)回 Lifecycle.Event，然后給觀察者分發(fā)出去。

/* Lifecycle.Event */ 
     @Nullable 
     public static Event upFrom(@NonNull State state) { 
         switch (state) { 
             case INITIALIZED: 
                 return ON_CREATE; 
             case CREATED: 
                 return ON_START; 
             case STARTED: 
                 return ON_RESUME; 
             default: 
                 return null; 
         } 
     } 

轉(zhuǎn)換 Event.upFrom ，發(fā)送 observer.dispatchEvent。

/* LifecycleRegistry  */ 
  private void forwardPass(LifecycleOwner lifecycleOwner) { 
      Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = 
              mObserverMap.iteratorWithAdditions(); 
      while (ascendingIterator.hasNext() && !mNewEventOccurred) { 
          Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next(); 
          ObserverWithState observer = entry.getValue(); 
          while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred 
                  && mObserverMap.contains(entry.getKey()))) { 
              pushParentState(observer.mState); 
              //轉(zhuǎn)化 
              final Event event = Event.upFrom(observer.mState); 
              if (event == null) { 
                  throw new IllegalStateException("no event up from " + observer.mState); 
              } 
              //發(fā)送 
              observer.dispatchEvent(lifecycleOwner, event); 
              popParentState(); 
          } 
      } 
  } 

11、 發(fā)送生命周期狀態(tài)

ObserverWithState 發(fā)送出 Lifecycle.Event ，至此就結(jié)束了，有注冊訂閱關(guān)系的地方就能收到

static class ObserverWithState { 
      State mState; 
      LifecycleEventObserver mLifecycleObserver; 
      ObserverWithState(LifecycleObserver observer, State initialState) { 
          mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer); 
          mState = initialState; 
      } 
      /* 分發(fā)生命周期狀態(tài) */ 
      void dispatchEvent(LifecycleOwner owner, Event event) { 
          State newState = event.getTargetState(); 
          mState = min(mState, newState); 
          mLifecycleObserver.onStateChanged(owner, event); 
          mState = newState; 
      } 
  } 

原理比較清晰：Activity/Fragment實(shí)現(xiàn)LifecycleOwner接口，通過LifecycleRegistry在對應(yīng)生命周期分發(fā)事件Lifecycle.Event，回調(diào)到生命周期觀察者LifecycleObserver對應(yīng)訂閱方法

總結(jié)

Lifecycle還是有可取之處的，相對于其它架構(gòu)組件之間的配合，Lifecycle更簡單且獨(dú)立;

LifecycleObserver接口( Lifecycle觀察者)：實(shí)現(xiàn)該接口的類，通過注解的方式，可以通過被LifecycleOwner類的addObserver(LifecycleObserver o)方法注冊,被注冊后，LifecycleObserver便可以觀察到LifecycleOwner的生命周期事件;

LifecycleOwner接口(Lifecycle持有者)：實(shí)現(xiàn)該接口的類持有生命周期(Lifecycle對象)，該接口的生命周期(Lifecycle對象)的改變會被其注冊的觀察者LifecycleObserver觀察到并觸發(fā)其對應(yīng)的事件;

Lifecycle(生命周期)：和LifecycleOwner不同的是，LifecycleOwner本身持有Lifecycle對象，LifecycleOwner通過其Lifecycle getLifecycle()的接口獲取內(nèi)部Lifecycle對象;

State(當(dāng)前生命周期所處狀態(tài));

Event(當(dāng)前生命周期改變對應(yīng)的事件)，當(dāng)Lifecycle發(fā)生改變，如進(jìn)入onCreate,會自動(dòng)發(fā)出ON_CREATE事件;

后面會陸續(xù)介紹一些官方架構(gòu)方面的知識點(diǎn);

本文轉(zhuǎn)載自微信公眾號「Android開發(fā)編程」