使用生命周期感知型組件處理生命周期

生命周期感知型組件可執(zhí)行操作來響應(yīng)另一個組件（如 Activity 和 Fragment）的生命周期狀態(tài)的變化。這些組件有助于您寫出更有條理且往往更精簡的代碼，這樣的代碼更易于維護(hù)。

一種常見的模式是在 Activity 和 Fragment 的生命周期方法中實現(xiàn)依賴組件的操作。但是，這種模式會導(dǎo)致代碼條理性很差而且會擴(kuò)散錯誤。通過使用生命周期感知型組件，您可以將依賴組件的代碼從生命周期方法移入組件本身中。

androidx.lifecycle 軟件包提供了可用于構(gòu)建生命周期感知型組件的類和接口 - 這些組件可以根據(jù) Activity 或 Fragment 的當(dāng)前生命周期狀態(tài)自動調(diào)整其行為。

注意：要將 androidx.lifecycle 導(dǎo)入 Android 項目，請參閱 Lifecycle 版本說明中關(guān)于聲明依賴項的說明。

在 Android 框架中定義的大多數(shù)應(yīng)用組件都存在生命周期。生命周期由操作系統(tǒng)或進(jìn)程中運行的框架代碼管理。它們是 Android 運作方式的核心，應(yīng)用必須遵循它們。如果不這樣做，可能會引發(fā)內(nèi)存泄露甚至應(yīng)用崩潰。

androidx.lifecycle 軟件包提供的類和接口可幫助您以彈性和隔離的方式解決這些問題。

生命周期

Lifecycle 是一個類，用于存儲有關(guān)組件（如 Activity 或 Fragment）的生命周期狀態(tài)的信息，并允許其他對象觀察此狀態(tài)。

Lifecycle 使用兩種主要枚舉跟蹤其關(guān)聯(lián)組件的生命周期狀態(tài)：

事件

從框架和 Lifecycle 類分派的生命周期事件。這些事件映射到 Activity 和 Fragment 中的回調(diào)事件。

狀態(tài)

由 Lifecycle 對象跟蹤的組件的當(dāng)前狀態(tài)。

您可以將狀態(tài)看作圖中的節(jié)點，將事件看作這些節(jié)點之間的邊。

類可以通過向其方法添加注解來監(jiān)控組件的生命周期狀態(tài)。然后，您可以通過調(diào)用 Lifecycle 類的 addObserver() 方法并傳遞觀察者的實例來添加觀察者，如以下示例中所示：

    public class MyObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        public void connectListener() {
            ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        public void disconnectListener() {
            ...
        }
    }

    myLifecycleOwner.getLifecycle().addObserver(new MyObserver());
    

在上面的示例中，myLifecycleOwner 對象實現(xiàn)了 LifecycleOwner 接口，我們將在接下來的部分中對該接口進(jìn)行說明。

LifecycleOwner

LifecycleOwner是單一方法接口，表示類具有 Lifecycle。它具有一種方法（即 getLifecycle()），該方法必須由類實現(xiàn)。如果您嘗試管理整個應(yīng)用進(jìn)程的生命周期，請參閱ProcessLifecycleOwner。

此接口從各個類（如 Fragment和 AppCompatActivity）抽象化Lifecycle 的所有權(quán)，并允許編寫與這些類搭配使用的組件。任何自定義應(yīng)用類均可實現(xiàn)LifecycleOwner接口。

實現(xiàn) LifecycleObserver的組件可與實現(xiàn) LifecycleOwner的組件無縫協(xié)同工作，因為所有者可以提供生命周期，而觀察者可以注冊以觀察生命周期。

對于位置跟蹤示例，我們可以讓 MyLocationListener 類實現(xiàn)LifecycleObserver，然后在 onCreate() 方法中使用 Activity 的 Lifecycle對其進(jìn)行初始化。這樣，MyLocationListener 類便可以“自給自足”，這意味著，對生命周期狀態(tài)的變化做出響應(yīng)的邏輯會在 MyLocationListener（而不是在 Activity）中進(jìn)行聲明。讓各個組件存儲自己的邏輯，可使 Activity 和 Fragment 邏輯更易于管理。

    class MyActivity extends AppCompatActivity {
        private MyLocationListener myLocationListener;

        public void onCreate(...) {
            myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
                // update UI
            });
            Util.checkUserStatus(result -> {
                if (result) {
                    myLocationListener.enable();
                }
            });
      }
    }
    

一個常見的用例是，如果 Lifecycle 現(xiàn)在未處于良好的狀態(tài)，則應(yīng)避免調(diào)用某些回調(diào)。例如，如果回調(diào)在 Activity 狀態(tài)保存后運行 Fragment 事務(wù)，就會引發(fā)崩潰，因此我們絕不能調(diào)用該回調(diào)。

為簡化此用例，Lifecycle 類允許其他對象查詢當(dāng)前狀態(tài)。

    class MyLocationListener implements LifecycleObserver {
        private boolean enabled = false;
        public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
           ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        void start() {
            if (enabled) {
               // connect
            }
        }

        public void enable() {
            enabled = true;
            if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
                // connect if not connected
            }
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        void stop() {
            // disconnect if connected
        }
    }
    

對于此實現(xiàn)，LocationListener 類可以完全感知生命周期。如果我們需要從另一個 Activity 或 Fragment 使用 LocationListener，只需對其進(jìn)行初始化。所有設(shè)置和拆解操作都由類本身管理。

如果庫提供了需要使用 Android 生命周期的類，我們建議您使用生命周期感知型組件。庫客戶端可以輕松集成這些組件，而無需在客戶端進(jìn)行手動生命周期管理。

實現(xiàn)自定義 LifecycleObserver

/**
 * 生命周期
 */
public class LifecycleActivity extends AppCompatActivity {

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

        getLifecycle().addObserver(new MyObserver());
    }

}

public class MyObserver implements LifecycleObserver {


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        log("onCreate()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        log("onStart()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        log("onResume()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        log("onPause()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        log("onStop()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        log("onDestroy()");
    }


    /**
     * 日志輸出
     *
     * @param msg
     */
    private void log(String msg) {
        Log.i("MyObserver", "log: --->" + msg);
    }

}

經(jīng)過上面的操作 MyObserver 也有了Activity的生命周期

實現(xiàn)原理源碼分析

一、Activity 實現(xiàn) Lifecycle

• LifecycleOwner 接口用于標(biāo)記其實現(xiàn)類具備 Lifecycle 對象
  ComponentActivity 和Fragment 都實現(xiàn)了該接口

 public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
 }
 
 class ComponentActivity implements LifecycleOwner{
 
    //LifecycleRegistry觀察者添加和事件分發(fā)  
   private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
      @NonNull
      @Override
      public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
      }

      @SuppressLint("RestrictedApi")
      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //往Activity上添加一個fragment,用以監(jiān)聽生命周期的變化
           //其目的是為了兼顧不是繼承自AppCompactActivity的場景.
            ReportFragment.injectIfNeededIn(this);
      }

     public ComponentActivity() {
         //添加觀察者
         getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
            }
        });
    }
} 

• Lifecycle接口Lifecycle 聲明了 添加觀察者 移除觀察者等相關(guān)函數(shù)（抽象）

public abstract class Lifecycle {

  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
  @NonNull
  AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();
  
  @MainThread 
  public abstract void addObserver(@NonNull LifecycleObserver observer);

  @MainThread
  public abstract void removeObserver(@NonNull LifecycleObserver observer);

  @MainThread
  @NonNull
  public abstract State getCurrentState();
}

• Event類(Lifecycle內(nèi)部靜態(tài)類)用于抽象 Activity/Fragment 的生命周期事件發(fā)生變化時所觸發(fā)的事件。例如，當(dāng) Activity 的每個生命周期事件回調(diào)函數(shù)（onCreate、onStart 等）被觸發(fā)時都會被抽象為相應(yīng)的 ON_CREATE、ON_START 兩個 Event

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

• State(Lifecycle內(nèi)部靜態(tài)類) 類用于標(biāo)記 Lifecycle 的當(dāng)前生命周期狀態(tài)

public enum State {        
  //當(dāng)處于 DESTROYED 狀態(tài)時，Lifecycle 將不會發(fā)布其它 Event 值       
  //當(dāng) Activity 即將回調(diào) onDestory 時則處于此狀態(tài)       
  DESTROYED,        
  //已初始化的狀態(tài)。例如，當(dāng) Activity 的構(gòu)造函數(shù)已完成，
  //但還未回調(diào) onCreate 時則處于此狀態(tài)        
  INITIALIZED,   
  CREATED,       
  STARTED,        
  RESUMED;                
  //如果當(dāng)前狀態(tài)大于入?yún)⒅?state 時，則返回 true    
  public boolean isAtLeast(@NonNull State state) {            
      return compareTo(state) >= 0;       
    } 
}

• LifecycleRegistry 觀察者添加和事件分發(fā)

public class LifecycleRegistry extends Lifecycle {
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState>       
                   mObserverMap =new FastSafeIterableMap<>();
  //一般一個 LifecycleRegistry 對應(yīng)一個 LifecycleOwner 對象（Activity/Fragment等）
  //mState 就用來標(biāo)記 LifecycleOwner 對象所處的當(dāng)前生命周期狀態(tài)
  private State mState;
  // 持有對 LifecycleOwner 的弱引用，避免內(nèi)存泄露
  private final WeakReference<LifecycleOwner> mLifecycleOwner;

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

• LifecycleRegistry addObserver 添加觀察者 將觀察者包裝成ObserverWithState 對象 存儲到 mObserverMap 中

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    //添加新的Observer時，會首先根據(jù)宿主的狀態(tài)計算出它的初始狀態(tài)，只要不是在onDestroy中注冊
   // 的，它的初始狀態(tài)都是INITIALIZED
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    //接著會把observer包裝成ObserverWithState，這個類主要是包含了觀察者及其狀態(tài)。每個事
    //件都會經(jīng)由這個對象類轉(zhuǎn)發(fā),這個類后面會來分析
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    //添加到集合，如果之前已經(jīng)添加過了，則return
    if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        //如果 LifecycleOwner 對象已經(jīng)被回收了，則直接返回
        return;
    }
    //如果 isReentrance 為 true，則說明此時以下兩種情況至少有一個成立：     
    //1. mAddingObserverCounter != 0。會出現(xiàn)這種情況，是由于開發(fā)者先添加了一個        
    //   LifecycleObserver ，當(dāng)還在向其回調(diào)事件的過程中，
    //在回調(diào)函數(shù)里又再次調(diào)用了 addObserver 方法添加了一個新的 LifecycleObserver       
   //2.mHandlingEvent 為 true。即此時正處于向外回調(diào) Lifecycle.Event 的狀態(tài)

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    //遞增加一，標(biāo)記當(dāng)前正處于向新添加的 LifecycleObserver 回調(diào) Event 值的過程
    mAddingObserverCounter++;
     
    //拿觀察者的狀態(tài)和宿主當(dāng)前狀態(tài)做比較，如果小于0，說明兩者狀態(tài)還沒有對齊
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        //將 observer 已經(jīng)遍歷到的當(dāng)前的狀態(tài)值 mState 保存下來
        pushParentState(statefulObserver.mState);
        //向 observer 回調(diào)進(jìn)入“statefulObserver.mState”前需要收到的 Event 值
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
       //移除 mState
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

• ObserverWithState 將外界傳入的 LifecycleObserver 對象傳給 Lifecycling 進(jìn)行類型包裝，將反射邏輯和接口回調(diào)邏輯都給匯總綜合成一個新的 LifecycleEventObserver 對象，從而使得 Event 分發(fā)過程都統(tǒng)一為一個入口

static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            //再一次根據(jù)需要分發(fā)的事件類型反推出該觀察者的狀態(tài)
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            //把事件分發(fā)給被包裝的對象，完成本次流程。
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
    
 //再一次根據(jù)需要分發(fā)的事件類型反推出該觀察者的狀態(tài),這樣的好處是事件與狀態(tài)對應(yīng)，不會出現(xiàn)跳躍   
static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }    

• Lifecycling.lifecycleEventObserver 獲取觀察者對象類型 根據(jù)傳入的不同觀察者對象類型返回不同的觀察者對象

 @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
        
        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
    ......一些反射邏輯....
}        

• LifecycleEventObserver和FullLifecycleObserver 都實現(xiàn)了 LifecycleObserver （Java多態(tài)）

public interface LifecycleObserver {

}

public interface LifecycleEventObserver extends LifecycleObserver {

    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

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

• FullLifecycleObserverAdapter 實現(xiàn)了 LifecycleEventObserver 接口，用于在收到 Lifecycle 生命周期事件狀態(tài)變化時，對其兩個構(gòu)造函數(shù)參數(shù)（ FullLifecycleObserver、LifecycleEventObserver）進(jìn)行生命周期事件做轉(zhuǎn)發(fā)

class FullLifecycleObserverAdapter implements LifecycleEventObserver {

    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }
    //進(jìn)行生命周期事件轉(zhuǎn)發(fā)
    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

• 以上對如何添加觀察者以及這些觀察者如何接受宿主生命周期變更事件做了分析，接下來分析宿主的生命周期變更是怎么分發(fā)出去的 還記得ComponentActivity中添加的那個ReportFragment嗎

 class ComponentActivity implements LifecycleOwner{
 
    //LifecycleRegistry觀察者添加和事件分發(fā)  
   private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
      @NonNull
      @Override
      public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
      }

      @SuppressLint("RestrictedApi")
      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //往Activity上添加一個fragment,用以監(jiān)聽生命周期的變化
           //其目的是為了兼顧不是繼承自AppCompactActivity的場景.
            ReportFragment.injectIfNeededIn(this);
      }
}

• ReportFragment 獲取到 AppCompatActivity 的事件變化通知，最終調(diào)用 LifecycleRegistry 的 handleLifecycleEvent(Lifecycle.Event) 方法將 Lifecycle.Event 傳遞出去。此時，LifecycleRegistry 就拿到了 Lifecycle.Event

public class ReportFragment extends Fragment {
   //添加到Activity
   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();
          // Hopefully, we are the first to make a transaction.
          manager.executePendingTransactions();
      }
   }

   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);
        }
     }
   }
  
   @Override
   public void onActivityCreated(Bundle savedInstanceState) {
      super.onActivityCreated(savedInstanceState);
      dispatch(Lifecycle.Event.ON_CREATE);
   }

   @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 onStop() {
    super.onStop();
    dispatch(Lifecycle.Event.ON_STOP);
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
  }
}

• 分發(fā)宿狀態(tài)的 handleLifecycleEvent 該方法會根據(jù)接收到的 Event 值換算出對應(yīng)的 State 值，然后更新本地的 mState，再向所有 Observer 進(jìn)行事件通知，最終還是會調(diào)用到 ObserverWithState 的 dispatchEvent 方法，所以后邊重點關(guān)注 dispatchEvent 方法即可

public class LifecycleRegistry extends Lifecycle {
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState>       
                   mObserverMap =new FastSafeIterableMap<>();

   public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    //根據(jù)接收到的 Event 值換算出對應(yīng)的 State 值
    State next = getStateAfter(event);
    moveToState(next);
   }

   private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
  }
}

-sync() 宿主生命周期狀態(tài)同步和分發(fā)

private void sync() {
        //mLifecycleOwner.get() 獲取到的是宿主（Activity/Fragment）
        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;
             //如果宿主當(dāng)前轉(zhuǎn)態(tài) 小于 mObserverMap集合中最先添加的那個觀察者的狀態(tài)
            //則說明宿主可能發(fā)生了狀態(tài)回退，比如當(dāng)前是RESUMED狀態(tài)，執(zhí)行了onPause則回退到
            //STARTED狀態(tài)
           //此時調(diào)用backwardPass把集合中的每個一觀察者分發(fā)一個on_pause事件，并同步它的狀態(tài)。
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            //如果宿主當(dāng)前轉(zhuǎn)態(tài) 大于 mObserverMap集合中最先添加的那個觀察者的狀態(tài)
        //則說明宿主可能發(fā)生了狀態(tài)前進(jìn)，比如當(dāng)前是STARTED狀態(tài)，執(zhí)行了onResume則前進(jìn)到
        //RESUMED狀態(tài)
        //此時調(diào)用forwardPass把集合中的每個一觀察者分發(fā)一個on_resume事件，并同步它的狀態(tài)。
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

• backwardPass和forwardPass 遍歷Map中保存的觀察者 進(jìn)行事件分發(fā)
  注意mNewEventOccurred 這個boolean值開關(guān) 是在有新的事件過來時能及時終止
  while循環(huán)分發(fā)沒有意義的事件

···
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
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));
//生命周期事件分發(fā)
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}

···

二、 Fragment 實現(xiàn) Lifecycle Fragment的實現(xiàn)和add到 AppCompatActivity中的 ReportFragment就打同小異了 一看就明白

···
public class Fragment implements LifecycleOwner{

LifecycleRegistry mLifecycleRegistry;

public Fragment() {
initLifecycle();
}

private void initLifecycle() {
mLifecycleRegistry = new LifecycleRegistry(this);
if (Build.VERSION.SDK_INT >= 19) {
mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_STOP) {
if (mView != null) {
mView.cancelPendingInputEvents();
}
}
}
});
}
}

@Override
@NonNull
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
//事件分發(fā)
void performCreate(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

void performStart(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}

void performResume(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
}

···

總結(jié)

• LifecycleOwner： Activity/Fragment 都實現(xiàn)了該接口，用以聲明它是一個能夠提供生命周期事件的宿主。同時必須復(fù)寫getLifecycle()方法提供一個Lifecycle對象
• Lifecycle：是一個抽象類，里面定義了兩個枚舉State宿主的狀態(tài)，Event 需要分發(fā)的事件的類型
• LifecycleRegistry: 是 Lifecycle 的唯一實現(xiàn)類，主要用來負(fù)責(zé)注冊 Observer(觀察者)，以及分發(fā)宿主狀態(tài)事件給它們

使用場景介紹

對平時開發(fā)中需要感知（Fragment/Activity）生命周期邏輯的地方 可以繼承LifecycleEventObserver或者 DefaultLifecycleObserver 并添加到 （Fragment/Activity）的 LifecycleRegistry中來觀察 （Fragment/Activity）生命周期的變化 而做出對應(yīng)的業(yè)務(wù)邏輯變化 (Ps:以前我們可能是在BaseActivity 或者BaseFragment的onStart()和onStop()添加對應(yīng)生命周期相關(guān)的邏輯 )

class LocationObserver extends DefaultLifecycleObserver{
    //宿主執(zhí)行了onstart時，會分發(fā)該事件
    void onStart(@NotNull LifecycleOwner owner){
        //開啟定位
    }
  
   //宿主執(zhí)行了onstop時 會分發(fā)該事件
   void onStop(@NotNull LifecycleOwner owner){
       //停止定位
   }
}
//2. 注冊觀察者,觀察宿主生命周期狀態(tài)變化
class MyFragment extends Fragment{
  public void onCreate(Bundle bundle){
    LocationObserver observer =new LocationObserver()
    //添加觀察者
    getLifecycle().addObserver(observer);
  }
 }