Android Jetpack - Lifecycle使用方法及原理分析

時間  2019-11-26
標籤 android jetpack lifecycle 使用方法 原理 分析 欄目 Android 简体版
原文   原文鏈接

Android Architecture Components

Android架構組件庫的集合,幫助您設計健壯的、可測試的、可維護的應用程序。從類管理UI組件的生命週期和處理數據持久性。java

一 Android常規生命週期管理方式node

二 Lifecycle的使用react

三 Lifecycle組件的關鍵類android

四 Lifecycle實現原理api

一 Android常規生命週期管理方式

在應用開發的過程當中，咱們常常須要根據 組件如 Activity/Fragment 的生命週期，來作相應的操做，若是代碼基於 MVP 架構開發，那麼咱們須要在 presenter 中定義好接口，如：架構

public interface ILoginPresenter {
    void login(String name, String pw);
    void onCreate();
    void onStart();
    void onResume();
    void onPause();
    void onStop();
    void onDestroy();
}
複製代碼

而後在 Activity/Fragment 相應的生命週期方法中，將不一樣的生命週期狀態回調給 presenter：app

@Override
protected void onStart() {
    super.onStart();
    mLoginPresenter.onStart();
}

@Override
protected void onResume() {
    super.onResume();
    mLoginPresenter.onResume();
}

@Override
protected void onPause() {
    super.onPause();
    mLoginPresenter.onPause();
}

@Override
protected void onStop() {
    super.onStop();
    mLoginPresenter.onStop();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mLoginPresenter.onDestroy();
}
複製代碼

儘管這樣看起來，代碼結構是清晰的，但這是在應用體量小的狀況下，想象一下，若是咱們在一個核心界面，該界面須要處理各類各樣的受當前組件生命週期影響的事物，那麼在該組件的生命週期方法中（onStart()/onResume()/onDestroy...）,咱們就須要去作大量的處理，以及時通知不一樣的 presenter 去作相應的操做，這將使得咱們的生命週期方法中的代碼變得冗雜。框架

並且組件的狀態是具有不肯定性的，例如咱們在 onResume() 方法中作了大量的工做去初始化組件，但這個初始化工做可能還沒作完，該組件就進入 stopped 狀態了。ide

此外，假如除了 presenter ，還有其餘類須要監聽組件的生命週期變化，那一樣須要新增不少生命週期回調接口，這時至關繁瑣的，那咱們是否能夠在組件的生命週期發生變化的時候主動通知須要該狀態的類呢？答案就是使用 Google提供Lifecycle組件，下面來看看使用 Lifecycle 組件，能帶來什麼樣的改善吧。函數

二 Lifecycle的使用

Google官方文檔 ： Handling Lifecycles with Lifecycle-Aware Components

先簡單介紹下使用 Lifecycle 的方法，後續再對幾個經常使用類及源碼實現展開細講

1.首先是依賴導入:

在應用/模塊的 build.gradle 文件中按需添加以下依賴

官網地址：Declaring dependencies

dependencies {
    def lifecycle_version = "2.1.0"

    // ViewModel and LiveData
    implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"
    // alternatively - just ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version" // For Kotlin use lifecycle-viewmodel-ktx
    // alternatively - just LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData). Some UI
    //     AndroidX libraries use this lightweight import for Lifecycle
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

    annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" // For Kotlin use kapt instead of annotationProcessor
    // alternately - if using Java8, use the following instead of lifecycle-compiler
    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version" // For Kotlin use lifecycle-reactivestreams-ktx

    // optional - Test helpers for LiveData
    testImplementation "androidx.arch.core:core-testing:$lifecycle_version"
}
複製代碼

生命週期observer須要作的：

2.讓須要監聽組件生命週期方法的observer實現 LifecycleObserver 接口，表示當前類是組件生命週期的觀察者

public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {...}
複製代碼

3.同時在須要被通知的接口上，添加 @OnLifecycleEvent(Lifecycle.Event.ON_XXX 註解, OnLifecycleEvent 對應了 組件 Activity/Fragment 的生命週期方法

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
@Override
public void onCreate() {
    Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
}

@OnLifecycleEvent(Lifecycle.Event.ON_START)
@Override
public void onStart() {
    Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
}
複製代碼

生命週期owner須要作的:

4.實現 LifecycleOwner 接口，代表本身是生命週期的擁有者

public class LoginActivity extends AppCompatActivity implements ILoginView, LifecycleOwner {...}
複製代碼

5.註冊observer，這樣就能在組件的生命週期變化時主動通知observer了

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 註冊須要監聽組件生命週期的 observer
    getLifecycle().addObserver(new LoginPresenterImpl());
}
複製代碼

到這裏，observer就能在owner每次生命週期變化時收到通知，相較於前面在owner的生命週期函數中逐個去手動通知各個observer，這種方式顯然更便捷。

下面看看log：

// step1 : 進入應用
com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: state=RESUMED

// step2 : 退出應用
com.example.lifecycletest2 D/LoginPresenterImpl: onPause: state=STARTED
com.example.lifecycletest2 D/LoginActivity: onPause: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onStop: state=CREATED
com.example.lifecycletest2 D/LoginActivity: onStop: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onDestroy: state=DESTROYED
com.example.lifecycletest2 D/LoginActivity: onDestroy: enter,state=DESTROYED
複製代碼

能夠看到，當 Activity 掛起後再次回到當前界面時，收到生命週期事件的順序變了，先看看官網對 Event && State 這兩個狀態是怎麼解釋的吧

Enent:

從框架和生命週期類Lifecycle分發過來的生命週期事件，這些事件對應活動和碎片中的生命週期回調事件

State:

由Lifecycle對象追蹤的組件當前的狀態

官方文檔是這麼說的：Think of the states as nodes of a graph and events as the edges between these nodes.也就是將state當作 圖的節點 ，將event當作 兩個節點之間的邊。看下下面的圖：

lifecycle-states.png

Google給出的 時間 && 狀態 的流程圖 結合上面的log打印，就很清晰了，即：

組件處於 INITIALIZED狀態 時，觸發 ON_CREATE 事件，分發事件onCreate()給observer，此時組件仍處於 INITIALIZED狀態 狀態，當observer收到onCreate()事件時，組件owner進入CREATED狀態，依次類推...

至於爲何上面log中，step1階段時是owner先收到生命週期事件，接着observer才收到；而 step2階段是 observer先收到生命週期事件，接着owner才收到。這個在 Lifecycle類 中有解釋，下面來看看

三 Lifecycle組件的關鍵類

上面介紹完簡單用法後，咱們來看下用到的幾個關鍵類：

1.抽象類Lifecycle

下面是該類給出的說明：

定義的一個持有Android生命週期的類。 Fragment 和 FragmentActivity 類實現了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都實現了LifecycleOwner接口 並 重寫了LifecycleOwner#getLifecycle() ，因此若是咱們的組件是繼承自以上類型組件的話，就不用再去實現 LifecycleOwner 接口而能夠直接調用 getLifecycle() 來獲取 Lifecycle

Event#ON_CREATE} && Event#ON_START && Event#ON_RESUME 這三個事件是在 LifecycleOwner 自身相關的生命週期方法返回後分發的，因此上面log的setp1中， Activity 先於監聽類收到生命週期函數回調。

Event#ON_PAUSE && Event#ON_STOP && Event#ON_DESTROY 這三個事件是在 LifecycleOwner 自身相關的生命週期方法被調用前分發的，因此上面log的setp2中，監聽類先於組件類收到回調。

清楚了這個以後，在監聽類中咱們就能夠確切得知道當前組件確切的生命週期節點了，而向上文提到的，onResume() 還沒作完就進入 onStopped()了，這種狀況也就迎刃而解了。

此外基於不一樣的Java版本，推薦使用的LifecycleObserver也有所區別：

  • 若是你用的是Java8，監聽組件生命週期時推薦繼承DefaultLifecycleObserver類，build.gradle中導入的包爲"androidx.lifecycle:common-java8:<version>"；
  • 若是你使用的是Java7，生命週期事件的監聽是經過註解實現的，監聽生命週期組件時繼承LifecycleObserver類。
  • 而Java8一旦成爲主流，註解的方式將被丟棄(註解經過反射實現，而反射須要的成本較大)，因此咱們使用的時候儘可能選擇DefaultLifecycleObserver。

上面的使用例子中用的就是LifecycleObserver，下面再來看看Java8上使用DefaultLifecycleObserver是怎麼樣的

監聽者

public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {

    private static final String TAG = "LoginPresenterImpl";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onCreate: owner=" + owner);
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStart: ");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onResume: ");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onPause: ");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onStop: ");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.d(TAG, "onDestroy: ");
    }
}
複製代碼

DefaultLifecycleObserver接口中定義了各個生命週期函數,因此咱們可在須要監聽組件生命週期的observer中按需重寫生命週期回調函數，而後在組件類中將監聽者添加到監聽列表（getLifecycle().addObserver(new LoginPresenterImpl());）便可收到回調了

能夠看到，若是咱們用的是DefaultLifecycleObserver接口，就再也不須要去給每一個須要監聽生命週期函數的方法添加註解了，使用上明顯更方便了，因此更推薦用這種方式

固然使用DefaultLifecycleObserver接口是有條件的，不然編譯會報錯：

default interface methods are only supported starting with Android N (--min-api 24): void androidx.lifecycle.DefaultLifecycleObserver.onCreate(androidx.lifecycle.LifecycleOwner)
複製代碼

也就是build.gradle文件中聲明的minSdkVersion必須大於等於24，不然會報錯，因此咱們使用的時候須要綜合Java版本 && minSdkVersion要求來作選擇。

接着來看該類提供了哪些方法：

// 添加一個生命週期觀察者，在 LifecycleOwner 生命週期改變時觀察者將能收到回調，例如
// 當 LifecycleOwner 處於 STARTED 時,觀察者將能收到 Event#ON_CREATE && Event#ON_START 兩個時間回調
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);

// 移除觀察者
這裏有幾種狀況：
若是該函數被調用時，某個生命週期狀態已經被分發出去了：
a.若是觀察者此時還未收到該事件，它將能繼續收到
b.若是觀察者類中有多個方法監聽了該事件且其中至少一個方法已經收到了該回調，
則剩餘全部的方法也都能收到該回調，全部回調完成後該觀察者纔會被移除
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);

// 獲取組件的生命週期狀態，一個經常使用場景是：當咱們要去觸發某個操做時，這個操做依賴於生命週期的狀態，
// 這時咱們能夠這麼作：if (lifecycle.getCurrentState().isAtLeast(STARTED)){ // TO DO }
@MainThread
@NonNull
public abstract State getCurrentState();

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

public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
    
    public boolean isAtLeast(@NonNull State state) {
        return compareTo(state) >= 0;
    }
}
複製代碼

2.接口LifecycleObserver觀察者

這是個空的接口，依賴於OnLifecycleEvent註解

3.接口LifecycleOwner/接口DefaultLifecycleObserver生命週期擁有者

  • 接口LifecycleOwner

只有一個方法**Lifecycle getLifecycle();**用於獲取Lifecycle對象

  • 接口DefaultLifecycleObserver

上文已經簡單敘述了該接口同LifecycleObserver的區別了，來看看該類給出的說明：若是一個監聽者同時實現了DefaultLifecycleObserver && LifecycleEventObserver，那麼DefaultLifecycleObserver的方法將會先被調用，隨後纔是LifecycleEventObserver#onStateChanged(LifecycleOwner, Lifecycle.Event)，若是一個類在實現該接口的同時還給方法添加OnLifecycleEvent註解，那麼相關注解將被忽視。

4.LifecycleEventObserver

上文提到了這個接口，來看下該類的描述：該類能接收任何生命週期改變同時分發給監聽者，這裏試了一下observer同時實現DefaultLifecycleObserver && LifecycleEventObserver，結合上面第3點，看下下面的log：

com.example.lifecycletest2 D/LoginActivity: onCreate: enter,state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_CREATE

com.example.lifecycletest2 D/LoginActivity: onStart: enter,state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_START

com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
com.example.lifecycletest2 D/LoginPresenterImpl: onResume: 
com.example.lifecycletest2 D/LoginPresenterImpl: onStateChanged: event=ON_RESUME
複製代碼

能夠看到，若是一個類同時實現了DefaultLifecycleObserver && LifecycleEventObserver，那麼會先調用相應的生命週期函數，接着纔是onStateChanged(),因此關於這兩個接口的選擇也就一目瞭然了，若是你須要在確切的生命週期作特定的事，那麼實現DefaultLifecycleObserver，若是你只是想在生命週期變化時被告知，能夠實現LifecycleEventObserver

5.LifecycleReistry

前面說過，Fragment 和 FragmentActivity 類自己實現了 LifecycleOwner 接口，Support Library 26.1.0 及以上的Activity && Fragment 也都實現了LifecycleOwner接口，而若是你的組件不是以上類型的呢（如android.app.Avtivity），這個時候若是你想實現上面一樣的效果的話就須要用到 LifecycleOwner + LifecycleReistry 了，下面來看看具體例子：

  • 組件類的實現：

    • a.實現LifecycleOwner接口

    • b.重寫getLifecycle()方法，並返回mLifecycleRegistry

    • c.建立LifecycleRegistry對象，並在但願通知監聽者的生命週期方法中用LifecycleRegistry.markState(Lifecycle.State.XXX)標記相應的狀態，

    • d.最後添加監聽者便可

      public class LoginActivity extends Activity implements ILoginView ,LifecycleOwner//a {

      private static final String TAG = "LoginActivity";
      private LifecycleRegistry mLifecycleRegistry;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          // c
          mLifecycleRegistry = new LifecycleRegistry(this);
          Log.d(TAG, "onCreate: state=" + getLifecycle().getCurrentState());
          mLifecycleRegistry.markState(Lifecycle.State.CREATED);
          // d
          getLifecycle().addObserver(new LoginPresenterImpl());
      }
  
      @Override
      protected void onStart() {
          super.onStart();
          Log.d(TAG, "onStart: state=" + getLifecycle().getCurrentState());
          mLifecycleRegistry.markState(Lifecycle.State.STARTED);
      }
  
      // b
      @NonNull
      @Override
      public Lifecycle getLifecycle() {
          return mLifecycleRegistry;
      }
  }
複製代碼

  • 監聽者的實現：有兩種，一種是實現LifecycleObserver，而後在但願監聽生命週期的函數上添加OnLifecycleEvent註解

    public class LoginPresenterImpl implements ILoginPresenter, LifecycleObserver {

      private static final String TAG = "LoginPresenterImpl";
  
      @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
      @Override
      public void onCreate() {
          Log.d(TAG, "onCreate: ");
      }
  
      @OnLifecycleEvent(Lifecycle.Event.ON_START)
      @Override
      public void onStart() {
          Log.d(TAG, "onStart: ");
      }
      
      @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
      @Override
      public void onResume() {
          Log.d(TAG, "onResume: ");
      }
  }
複製代碼

log打印以下

com.example.lifecycletest2 D/LoginActivity: onCreate: state=INITIALIZED
com.example.lifecycletest2 D/LoginPresenterImpl: onCreate: 

com.example.lifecycletest2 D/LoginActivity: onStart: state=CREATED
com.example.lifecycletest2 D/LoginPresenterImpl: onStart: 
// owner 中未用 markState 標記，因此 observer 沒法收到回調
com.example.lifecycletest2 D/LoginActivity: onResume: enter,state=STARTED
複製代碼

能夠看到，只有在owner中使用LifecycleRegistry.markState(Lifecycle.State.XXX)標記了的函數，監聽者才能收到回調。

  • 監聽者的另外一種實現：實現DefaultLifecycleObserver接口，按需實現須要的回調函數，

    public class LoginPresenterImpl implements ILoginPresenter, DefaultLifecycleObserver {

      private static final String TAG = "LoginPresenterImpl";
  
      @Override
      public void onCreate(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onCreate: ");
      }
  
      @Override
      public void onStart(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onStart: ");
      }
  
      @Override
      public void onResume(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onResume: ");
      }
  
      @Override
      public void onPause(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onPause: ");
      }
  
      @Override
      public void onStop(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onStop: ");
      }
  
      @Override
      public void onDestroy(@NonNull LifecycleOwner owner) {
          Log.d(TAG, "onDestroy: ");
      }
  }
複製代碼

log打印結果同上，一樣是隻有用LifecycleRegistry.markState標記過的生命週期函數纔會自動通知到監聽者類中。

四 Lifecycle實現原理

看完Lifecycle的用法後，咱們來看看它是怎麼實現的：

相信你們也是不少疑惑的，Lifecycle組件這套邏輯是怎麼搭起來的，Activity/Fragment 是怎麼在生命週期變化的時候自動通知到觀察者的？

首先解答一個疑問：自定義實現LifecycleOwner必須重寫getLifecycle()方法並返回一個LifecycleRegistry實例，那麼不須要咱們手動重寫getLifecycle()的組件，是在哪一個地方幫咱們作了這件事呢,下面來看看：

若是咱們的Activity是繼承自AppCompatActivity，咱們就不須要再手動去實現LifecycleOwner了，咱們往上追溯能夠發現，父類ComponentActivity實現了該接口，其getLifecycle()方法返回了一個LifecycleRegistry實例，因此就是在這裏幫咱們作了這件事的。

先思考下面兩個問題：

  • 往LifecycleRegistry中添加監聽者後，LifecycleRegistry是怎麼感知組件的生命週期變化的?
  • LifecycleRegistry是如何將生命週期變化分發到對應的observer的？

核心實現涉及兩個類：ComponentActivity && LifecycleRegistry

ComponentActivity#onCreate():

有這麼一行代碼ReportFragment.injectIfNeededIn(this),這個FragmentManager是什麼，injectIfNeededIn()方法又作了什麼事？

public class ReportFragment extends Fragment {
    
    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();
        manager.executePendingTransactions();
    }
    
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }
    
    // 分發生命週期函數到 LifecycleRegistry 
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }
    ...
}
複製代碼

類的註釋是：一個分發初始化事件的內部類，上面貼出了該類的幾個關鍵方法：

a.首先是injectIfNeededIn()方法，建立了一個Fragment而後添加到Activity中去

b.在該Fragment的生命週期函數中都調用了dispatch(Lifecycle.Event event)方法，而該方法作的就是，判斷當前Activity是否實現了LifecycleRegistryOwner/LifecycleOwner接口，是的話就調用LifecycleRegistry#handleLifecycleEvent(event)

到這裏咱們就能夠明白了第一個問題了，即經過添加一個Fragment到當前Activity中，而後利用Fragment與Activity的生命週期函數先後調用關係，來感知Activity的生命週期。

來看看LifecycleRegistry#handleLifecycleEvent(event)又作了什麼,關鍵代碼都作了註釋

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // 根據 owner 傳過來的生命週期事件，拿到要分發給 observer 的狀態
    State next = getStateAfter(event);
    // 將狀態分發給 observer
    moveToState(next);
}

// moveToState(State next) 中的關鍵代碼只有一句：調用 sync()
private void sync() {
    ......
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 分發點1
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            // 分發點2
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

// 分發點1
private void forwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    // 遍歷當前的 observer 
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            pushParentState(observer.mState);
            // 將生命週期時間分發到每一個 observer
            observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
            popParentState();
        }
    }
}

// 分發點2
private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    // 遍歷當前的 observer 
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = downEvent(observer.mState);
            pushParentState(getStateAfter(event));
            // 將生命週期時間分發到每一個 observer
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}
複製代碼

看到這裏咱們能明白第二個問題了，即ReportFragment在自身的生命週期函數中，將當前生命週期事件報告給LifecycleRegistry, 而LifecycleRegistry經由addObserver(observer),是持有各個observer的引用的，這樣便能將收到的報告轉發給各個observer了。

整個流程用了一個很巧妙的技巧：利用一個Fragment以及 Fragment的各個生命週期函數與Activity的生命週期函數的先後調用關係，以LifecycleRegistry爲橋樑，將Activity的生命週期分發給observer。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程