源碼進階之lifecycle組件原理分析

作者：Android開發編程 2021-09-05 07:35:58

如何利用 android.arch.lifecycle 包提供的類來控制數據、監聽器等的 lifecycle。同時，LiveData 與 ViewModel 的 lifecycle 也依賴于 Lifecycle 框架;今天我們就來聊聊lifecycle的實現原理，來一波分析。

[[421728]]

前言

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

今天我們就來聊聊lifecycle的實現原理，來一波分析

一、為什么要引進Lifecycle?

1、沒有引進Lifecycle做法

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

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

代碼沒有問題，關鍵問題是，實際生產環境中，這樣的代碼會非常復雜，你最終會有太多的類似調用并且會導致 onCreate() 和 onDestroy() 方法變的非常臃腫;

2、引進Lifecycle做法

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

代碼如下：

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 中，這樣每一個BasePresenter 的子類都能感知到Activity容器對應的生命周期事件，并在子類重寫的方法中，對應相應行為

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

每當Activity發生了對應的生命周期改變，Presenter就會執行對應事件注解的方法

二、Lifecycle原理層層深入分析

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

1、 onCreate

在ComponentActvitiy的 onCreate 方法里面可以看到 ReportFragment 的創建。 
    /* 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 是個枚舉類，這里的生命周期 Event 并不是Fragment的，在后面的生命周期處理時會用上的。

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

4、 ReportFragment的創建

ReportFragment 是一個沒有界面的Fragment，如果有了解過Glide原理的同學，應該也知道這個方法，就是通過看不見的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 實現了 Application.ActivityLifecycleCallbacks接口，在SDK29以上的生命周期分發是由Application 分發的，activity注冊就能回調。

大名鼎鼎的LeakCanary在監聽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的各個生命周期方法里，會調用 dispatch 方法。

比如 onActivityCreated。

反正無論是使用 LifecycleCallbacks.registerIn(activity)，還是 Fragment 的生命周期回調，最后都會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個但是生命周期可是不止5個，所以Google他們設計時，就創建流程正著走，銷毀流程就反正走。

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，所以他們最后都會執行 LifecycleRegistry 的 handleLifecycleEvent 方法。

就是把 Lifecycle.Event處理一下，轉化成 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 繼續往下傳，先用 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狀態 
      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

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

/* 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. 
           //上一個方法保存的mState，跟組件之前的的mState對比 
           if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) { 
               //返向執行流程 
               backwardPass(lifecycleOwner); 
           } 
           Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); 
           if (!mNewEventOccurred && newest != null 
                   && mState.compareTo(newest.getValue().mState) > 0) { 
               //正向執行流程 
               forwardPass(lifecycleOwner); 
           } 
       } 
       mNewEventOccurred = false; 
   }

10、 forwardPass

反向的邏輯差不多，只是執行 backwardPass ，先轉換Stata，最后執行 observer.dispatchEvent。

這里又把 Lifecycle.State 轉回 Lifecycle.Event，然后給觀察者分發出去。

/* 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; 
         } 
     }

轉換 Event.upFrom ，發送 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); 
              //轉化 
              final Event event = Event.upFrom(observer.mState); 
              if (event == null) { 
                  throw new IllegalStateException("no event up from " + observer.mState); 
              } 
              //發送 
              observer.dispatchEvent(lifecycleOwner, event); 
              popParentState(); 
          } 
      } 
  }

11、發送生命周期狀態

ObserverWithState 發送出 Lifecycle.Event ，至此就結束了，有注冊訂閱關系的地方就能收到

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 = event.getTargetState(); 
          mState = min(mState, newState); 
          mLifecycleObserver.onStateChanged(owner, event); 
          mState = newState; 
      } 
  }

原理比較清晰：Activity/Fragment實現LifecycleOwner接口，通過LifecycleRegistry在對應生命周期分發事件Lifecycle.Event，回調到生命周期觀察者LifecycleObserver對應訂閱方法

總結

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

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

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

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

State(當前生命周期所處狀態);

Event(當前生命周期改變對應的事件)，當Lifecycle發生改變，如進入onCreate,會自動發出ON_CREATE事件;

后面會陸續介紹一些官方架構方面的知識點;

本文轉載自微信公眾號「Android開發編程」

責任編輯：姜華來源： Android開發編程