Jetpack系列 - Lifecycle

前言

本文將開始Jetpack系列之Lifecycle的學習,為什么先說Lifecycle呢,因為Lifecycle是Jetpack的核心,我們熟悉的ViewModel,LiveData都是基于它實現的。(關于Jetpack大家也可以直接看Jetpack官網

看完本文可以達到什么程度

  • 掌握Lifecycle的基本原理及使用
  • 掌握Activity Fragment是如何實現Lifecycle的。
  • 掌握Lifecycle宿主分發

如果您已經達到上面的程度,那么可以不看下文了;

什么是Jetpack

簡單點總結就是:Jetpack是眾多組件的統稱,而AndroidX是這些組件的統一包名。


什么是Lifecycle

Lifecycle也即是Jetpack眾多組件之一,這個組件庫代碼也就是小十個類,如下:


Lifecycle庫.png

簡單點總結就是:Lifecycle組件抽象出了一套觀察者(繼承LifecycleObserver),被觀察者(繼承LifecycleOwner,例如Fragment),以及他們兩之間事件分發 的能力。

Lifecycle簡單流程.png
  • Lifecycle是一個能感知宿主(LifecycleOwner)生命周期的組件。
  • 允許其它觀察者監聽宿主生命周期狀態。
  • 省略了以前手動分發宿主生命周期的操作.(例如在onDestroy中去調用三方組件的銷毀)。
  • 宿主如何分發生命周期狀態?之后再詳細分析。


Lifecycle的使用

1). 首先得添加依賴,以下兩種選一種就行

 //通常情況下,只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
 //如果想單獨使用,可引入下面這個依賴
api 'androidx.lifecycle:lifecycle-common:2.1.0'

2). 使用有如下三種方式:

  • 實現LifecycleObserver,并使用@OnLifecycleEvent注解
// 1.自定義的組件,也是LifecycleObserver觀察者
class MyObserver implements LifecycleObserver {
    // 在對應的方法上用注解聲明想要觀察的宿主生命周期
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner){
        // 宿主(例如Fragment)的onCreate事件分發
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(LifecycleOwner owner){
        // 宿主(例如Fragment)的onDestroy事件分發
    }
}
// 1.Fragment繼承了LifecycleOwner,是個宿主
// 2.注冊觀察者,觀察宿主生命周期變化
class MyFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        MyObserver observer = new MyObserver();
        getLifecycle().addObserver(observer);
    }
}
  • 實現FullLifecyclerObserver,擁有生命周期所有事件,但FullLifecyclerObserver類對外不可見。
class MyObserver1 implements FullLifecycleObserver {
    @Override
    public void onCreate(LifecycleOwner owner) {
    }
    @Override
    public void onStart(LifecycleOwner owner) {
    }
    @Override
    public void onResume(LifecycleOwner owner) {
    }
    @Override
    public void onPause(LifecycleOwner owner) {
    }
    @Override
    public void onStop(LifecycleOwner owner) {
    }
    @Override
    public void onDestroy(LifecycleOwner owner) {
    }
}
  • LifecycleEventObserver宿主生命周期事件封裝成 Lifecycle.Event,觀察者根據Lifecycle.Event區分宿主的不同生命周期
// 源碼
public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

class MyObserver2 implements LifecycleEventObserver {
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event){
            case ON_CREATE:
                // 宿主onCreate生命周期
                break;
            case ON_DESTROY:
                // 宿主onDestroy生命周期
                break;
        }
    }
}

3). 我們的Activity跟Fragment都是LifecycleOwner;也就是說一些自定義組件可以通過addObserver,在組件內部獲得Activity跟Fragment的生命周期回調;舉個例子:

/**
*  倒計時組件
*  1. 最原始的做法我們需要在Activity或Fragment的onDestroy中手動去停止。萬一漏了就可能造成內存泄漏問題。
*  2. 有了Lifecycle,就能在組件內部去處理,再也不怕內存泄漏了
*/
public class CountDownTextView extends AppCompatTextView implements LifecycleObserver {
public CountDownTextView(......) {
        super(......);
        // 自動注冊
        autoBindLifecycle(context);
    }
}
private void autoBindLifecycle(Context context) {
    ...
    xxx.getLifecycle().addObserver(this);
    ...
}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onDestroy() {
    // 自動去做一些停止,釋放資源等操作
    ......
}


Fragment如何實現Lifecycle

先看看整體架構圖:


Lifecycle-fragment架構.png

Fragment中代碼如下:

public class Fragment implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  @Override
  public Lifecycle getLifecycle() {  
      //復寫自LifecycleOwner,所以必須new LifecycleRegistry對象返回
      return mLifecycleRegistry;
  }
  
void performCreate(){
     mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
  }
  
 void performStart(){
     mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
  }
  .....
 void performResume(){
     mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
  }  
}
  • Fragment實現了LifecycleOwner接口,是一個能提供生命周期事件的宿主
  • Fragment中通過Lifecycle addObserver(),來添加觀察者。
  • Fragment中通過Lifecycle的具體實現類LifecycleRegistry來進行生命周期事件的分發。


Activity如何實現Lifecycle

Activity的實現跟Fragment稍有不同,不是利用自己的生命周期去分發事件,而是添加一個Fragment,通過Fragment的生命周期去分發。(為啥這樣設計??)

public class ComponentActivity extends Activity implements LifecycleOwner{
  private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
   @NonNull
   @Override
   public Lifecycle getLifecycle() {
      return mLifecycleRegistry;
   }
  
  protected void onCreate(Bundle bundle) {
      super.onCreate(savedInstanceState);
      //往Activity上添加一個fragment,用以報告生命周期的變化
      //目的是為了兼顧不是繼承自AppCompactActivity的場景.
      ReportFragment.injectIfNeededIn(this); 
}

ReportFragment的實現原理跟Fragment類似,通過LifecycleRegistry對生命周期事件分發。

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 onStart() {
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }
    @Override
    public void onResume() {
        super.onResume();
        dispatch(Lifecycle.Event.ON_RESUME);
    }
    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
    }
    private void dispatch(Lifecycle.Event event) {
         Lifecycle lifecycle = activity.getLifecycle();
         if (lifecycle instanceof LifecycleRegistry) {
             ((LifecycleRegistry)   lifecycle).handleLifecycleEvent(event);
         }
}


生命周期事件及狀態

先明確兩個概念:Lifecycle類中有兩個枚舉,Event(事件),State(狀態)。

Event:當宿主的生命周期有變化時,會發送相應的事件Event,如下:

void performCreate(Bundle savedInstanceState) {
  mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

State:Lifecycle的實現類LifecycleRegistry中保存了mState,代表當前宿主的狀態;宿主發送不同的事件,相應的State也會變化。

Event和State關系如下:

Lifecycle事件及狀態.png


事件分發原理

首先先思考一個問題:如果是在Fragment的onResume中注冊一個Observer,這個Observer還能收到Fragment的oncreate,onstart,onresume事件嗎?
這里先給答案:可以收到,這幾個事件在addObserver方法中就會去分發。
以這個為例來講講lifecycle的事件分發原理,主要看下LifecycleRegistry流程,先見下圖:


LifecycleRegistry主要流程.png

上圖就是一個大致的了解,要詳細的認知還是得看源碼:

Step1:初始化

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

這個構造方法就是在Fragment的構造方法中調用,主要是對mState做了個初始化INITIALIZED

Step2:注冊Observer

以下代碼只展示一些主流程

public void addObserver(@NonNull LifecycleObserver observer) {
        // 1.添加新的Observer時,會根據宿主狀態計算observer的初始狀態
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 2.把初始狀態跟observer封裝成一個新的對象ObserverWithState
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 3. 計算宿主對象的狀態
        State targetState = calculateTargetState(observer);
        ......
}
// Observer對象的封裝對象
static class ObserverWithState {
        State mState;
      // 所有的Observer會轉成LifecycleEventObserver類型
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }
       // 事件發送
        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

把observer與State封裝成ObserverWithState,這個對象對把observer統一轉成LifecycleEventObserver類型;怎么轉的大家可以詳細看下Lifecycling中lifecycleEventObserver,這里不展開敘述了

Step3:對比Observer狀態跟宿主狀態

public void addObserver( LifecycleObserver observer) {
      以上是Step2
      ......
      // 1. 拿觀察者的狀態和宿主當前狀態做比較,如果小于0,說明兩者狀態還沒有對齊
      while ((statefulObserver.mState.compareTo(targetState) < 0,...){
          ......
      // 2.接著就會分發一次相應的事件,于此同時statefulObserver的mState對象也會被升級
          statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
      // 3.再一次計算觀察者應該到達的狀態
          targetState = calculateTargetState(observer);
      }
}



在以上三步后,在onResume中注冊的Observer就能收到oncreate,onstart,onresume三個事件。當宿主在執行其他的生命周期時,會通過handleLifecycleEvent發送相應的事件。

Step4:宿主發送相應事件

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
      // 1. 獲取事件相對應的狀態
        State next = getStateAfter(event);
      // 2.同步到該狀態,給所有的Observer發送事件
        moveToState(next);
    }


總結

看完本篇再回到開頭的幾項目標,是不是都掌握了呢?還沒掌握可以對著源碼再細細屢屢,相信一定能掌握Lifecycle的核心,之后要講的LiveData,ViewModel都是基于它來實現的。

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

推薦閱讀更多精彩內容