是什么

是具備宿主生命周期感知能力的組件闲擦。它能持有組件（如 Activity 或 Fragment）生命周期狀態(tài)的信息，并且允許其他觀察者監(jiān)聽(tīng)宿主的狀態(tài)场梆。

各類之間的關(guān)系

各類之間的關(guān)系

如何使用 Lifecycle 觀察宿主狀態(tài)

1. LifecycleObserver 配合注解
這種方式需要添加lifecycle-compiler注解處理器墅冷。

//1. 自定義的LifecycleObserver觀察者，在對(duì)應(yīng)方法上用注解聲明想要觀  察的宿主的生命周期事件即可
class LocationObserver extends LifecycleObserver{

  //宿主執(zhí)行了onstart時(shí)辙谜，會(huì)分發(fā)該事件
  @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NotNull LifecycleOwner owner){
      //開(kāi)啟定位
    }
  
  //宿主執(zhí)行了onstop時(shí) 會(huì)分發(fā)該事件
  @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
  void onStop(@NotNull LifecycleOwner owner){
     //停止定位
  }
 }

//2. 注冊(cè)觀察者,觀察宿主生命周期狀態(tài)變化
class MyFragment extends Fragment{
  public void onCreate(Bundle bundle){
    LocationObserver observer =new LocationObserver()
    getLifecycle().addObserver(observer);
  }
}

2. FullLifecyclerObserver 擁有宿主所有生命周期事件

//1.源碼俺榆，目前這個(gè)類權(quán)限不可見(jiàn)，即便如此装哆，我們也要了解它
interface FullLifecycleObserver extends LifecycleObserver {
    void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);
}

//2.用法,需要監(jiān)聽(tīng)那個(gè)事件，復(fù)寫(xiě)那個(gè)方法即可
class LocationObserver extends FullLifecycleObserver{
    void onStart(LifecycleOwner owner){}
    void onStop(LifecycleOwner owner){}
}

3. LifecycleEventObserver宿主生命周期事件封裝成 Lifecycle.Event

//1.源碼
public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

//2.用法 
class LocationObserver extends LifecycleEventObserver{
    @override
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event){
      //需要自行判斷l(xiāng)ife-event是onstart, 還是onstop
    }
}

Fragment 是如何實(shí)現(xiàn) Lifecycle 的

在各個(gè)生命周期方法內(nèi)利用LifecycleRegistry分發(fā)相應(yīng)的事件給每個(gè)觀察者定嗓。

public class Fragment implements LifecycleOwner {

    LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    @Override
    public Lifecycle getLifecycle() {  
      //復(fù)寫(xiě)自LifecycleOwner,所以必須new LifecycleRegistry對(duì)象返回
      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);
     }  
}

Activity 是如何實(shí)現(xiàn) Lifecycle 的

借助于 ReportFragment 往 Activity 上添加一個(gè) fragment 用以報(bào)告生命周期的變化蜕琴。目的是為了兼顧不是繼承自 AppCompactActivity 的場(chǎng)景， 同時(shí)也支持我們自定義 LifecycleOwner 的場(chǎng)景宵溅。

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上添加一個(gè)fragment,用以報(bào)告生命周期的變化
      //目的是為了兼顧不是繼承自AppCompactActivity的場(chǎng)景.
      ReportFragment.injectIfNeededIn(this); 
    }
    
}

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

宿主生命周期與宿主狀態(tài)模型圖

宿主生命周期與宿主狀態(tài)模型圖

Lifecycle添加observer的源碼分析

// LifecycleRegistry.class
public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        
        // 添加新的Observer時(shí)凌简，會(huì)首先根據(jù)宿主的狀態(tài)計(jì)算出它的初始狀態(tài)，只要不是在onDestroy中注冊(cè)的恃逻，它的初始狀態(tài)都是INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        
        // 接著會(huì)把observer包裝成ObserverWithState雏搂，這個(gè)類主要是包含了觀察者及其狀態(tài)。每個(gè)事件都會(huì)經(jīng)由這個(gè)對(duì)象類轉(zhuǎn)發(fā)
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        
        // 添加到集合寇损，如果之前已經(jīng)添加過(guò)了凸郑，則return
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        if (previous != null) {
            return;
        }
        
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // 頁(yè)面被回收時(shí)為null，return
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        
        // 計(jì)算目標(biāo)state矛市，之后會(huì)將當(dāng)前state和目標(biāo)state之間的所有event回調(diào)給observer
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        
        // 拿觀察者的狀態(tài)和宿主當(dāng)前狀態(tài)做比較芙沥，如果小于0，說(shuō)明兩者狀態(tài)還沒(méi)有對(duì)齊
        while ((statefulObserver.mState.compareTo(targetState) < 0 && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            
            // 獲取下一個(gè)生命周期事件對(duì)應(yīng)的event，例如當(dāng)前state是INITIALIZED而昨，則下一個(gè)生命周期事件對(duì)應(yīng)的event是ON_CREATE
            final Event event = Event.upFrom(statefulObserver.mState);
            
            // 如果當(dāng)前state沒(méi)有對(duì)應(yīng)的下一個(gè)event救氯，拋異常
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            
            //  分發(fā)event
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();
            // 頁(yè)面狀態(tài)可能發(fā)生變化，重新計(jì)算目標(biāo)state歌憨，繼續(xù)做循環(huán)和目標(biāo)state做比較着憨，直到兩者一樣
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            // 狀態(tài)同步過(guò)程中，宿主狀態(tài)可能有變動(dòng)务嫡，比如由RESUMED-> STARTED甲抖，調(diào)用sync()完成事件的分發(fā)和觀察者狀態(tài)的同步
            sync();
        }
        mAddingObserverCounter--;
}


// ObserverWithState.class，持有觀察者及其狀態(tài)的內(nèi)部類
static class ObserverWithState {
        // 持有Observer的狀態(tài)植袍，方便與宿主狀態(tài)做比對(duì)同步：
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            // 根據(jù)observer的類型（FullLifecycleObserver惧眠、LifecycleEventObserver）轉(zhuǎn)換成對(duì)應(yīng)的適配器類，適配器類會(huì)對(duì)onStateChanged方法進(jìn)行適配于个，并以相應(yīng)的方式(反射氛魁、中轉(zhuǎn))把事件轉(zhuǎn)發(fā)到我們的observer上；統(tǒng)一事件的分發(fā)形式厅篓。
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            // observer初始狀態(tài)：INITIALIZED秀存、DESTROYED
            mState = initialState;
        }

        // 分發(fā)event
        void dispatchEvent(LifecycleOwner owner, Event event) {
            // 根據(jù)event獲取對(duì)應(yīng)的state
            State newState = event.getTargetState();
            mState = min(mState, newState);
            // 回調(diào)通知observer生命周期事件
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
}

sequenceDiagram
LifecycleRegistry->>LifecycleRegistry: addObserver( LifecycleObserver) 

LifecycleRegistry->>LifecycleRegistry: calculateTargetState(observer)

LifecycleRegistry->>ObserverWithState: dispatchEvent(owner, event)

宿主生命周期變化后相應(yīng)事件的分發(fā)

// LifecycleRegistry.class
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        // 獲取event對(duì)應(yīng)的state，同步observer的state
        moveToState(event.getTargetState());
}


private void moveToState(State next) {
        // 如果LifecycleRegistry的狀態(tài)沒(méi)有改變羽氮，不做處理
        if (mState == next) {
            return;
        } 
        
        // 保存宿主state
        mState = next;
        
        // 如果正在分發(fā)生命周期事件 或者 剛注冊(cè)了observer(也是正在分發(fā)生命周期事件)或链，則不做處理，因?yàn)楹竺娑紩?huì)調(diào)sync()同步所有observer的狀態(tài)
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        
        // 同步觀察者狀態(tài)
        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
}


// 同步LifecycleRegistry注冊(cè)了的所有observer的狀態(tài)
private void sync() {
        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.");
        }
        
        // 如果observer的狀態(tài)和LifecycleRegistry的狀態(tài)不同步档押，則同步它們的狀態(tài)
        while (!isSynced()) {
            mNewEventOccurred = false;
            
            // mObserverMap中的節(jié)點(diǎn)以鏈表的形式連接
            // 如果宿主state小于最先添加的observer(頭節(jié)點(diǎn))的state澳盐，則說(shuō)明宿主可能發(fā)生了狀態(tài)回退，比如當(dāng)前是RESUMED狀態(tài)令宿，執(zhí)行了onPause則回退到STARTED狀態(tài)叼耙，此時(shí)調(diào)用backwardPass把集合中的每個(gè)一觀察者分發(fā)一個(gè)on_pause事件，并同步它的狀態(tài)粒没，即將所有observer的state回退到和宿主state一致
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            // 如果宿主state大于最后的observer(尾節(jié)點(diǎn))的state筛婉，則說(shuō)明宿主可能發(fā)生了狀態(tài)前進(jìn)，比如當(dāng)前是STARTED狀態(tài)癞松，執(zhí)行了onResume則前進(jìn)到RESUMED狀態(tài)爽撒，此時(shí)調(diào)用forwardPass把集合中的每個(gè)一觀察者分發(fā)一個(gè)on_resume事件，并同步它的狀態(tài)响蓉。
            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
}