在線看源碼地址：
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/
如需git clone，可使用下面兩個地址
https://android.googlesource.com/platform/frameworks/support/
https://github.com/androidx/androidx
如需將 androidx.lifecycle導(dǎo)入 Android 項(xiàng)目，請參閱 Lifecycle 版本說明中關(guān)于聲明依賴項(xiàng)的說明。
1.lifecycle是什么
是androidx下的一個軟件包，里面有l(wèi)ivedata，viewmodel等。
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/
這個package下有一個類，叫Lifecycle.java
2.LifeCycle
Lifecycle 是一個類，用于存儲有關(guān)組件（如 Activity 或 Fragment）的生命周期狀態(tài)的信息，并允許其他對象觀察此狀態(tài)。
https://developer.android.com/topic/libraries/architecture/lifecycle?hl=zh-cn
androidx.lifecycle 軟件包 提供了可用于構(gòu)建生命周期感知型組件的類和接口- 這些組件可以根據(jù) Activity 或 Fragment 的當(dāng)前生命周期狀態(tài)自動調(diào)整其行為。
在 Android 框架中定義的大多數(shù)應(yīng)用組件都存在生命周期。生命周期由操作系統(tǒng)或進(jìn)程中運(yùn)行的框架代碼管理。它們是 Android 工作原理的核心，應(yīng)用必須遵循它們。如果不這樣做，可能會引發(fā)內(nèi)存泄漏甚至應(yīng)用崩潰。
簡單來說，activity和fragment 這種Android框架中的組件是有生命周期的，但是自定義的一些類，是沒有生命周期的，通過使用lifecycle 軟件包，可以使自定義的類，具備感知生命周期的功能。
Lifecycle 是個抽象類，下面簡單列出幾個關(guān)鍵點(diǎn)。
public abstract class Lifecycle {
/**
* Adds a LifecycleObserver that will be notified when the LifecycleOwner changes
* state.
* <p>
* The given observer will be brought to the current state of the LifecycleOwner.
* For example, if the LifecycleOwner is in {@link State#STARTED} state, the given observer
* will receive {@link Event#ON_CREATE}, {@link Event#ON_START} events.
*
* @param observer The observer to notify.
*/
//注釋簡單翻譯
// 添加一個 LifecycleObserver，當(dāng) LifecycleOwner 發(fā)生變化時會收到通知狀態(tài)
//例如，如果 LifecycleOwner 處于 {@link State#STARTED} 狀態(tài)，則給定的觀察者將接收 {@link Event#ON_CREATE}、{@link Event#ON_START} 事件
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
}
@SuppressWarnings("WeakerAccess")
public enum Event {
/**
* Constant for onCreate event of the {@link LifecycleOwner}.
*/
ON_CREATE,
/**
* Constant for onStart event of the {@link LifecycleOwner}.
*/
ON_START,
...
}
/**
* Lifecycle states. You can consider the states as the nodes in a graph and
* {@link Event}s as the edges between these nodes.
*/
@SuppressWarnings("WeakerAccess")
public enum State {
/**
* Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onStart() onStart} call;
* <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
* </ul>
*/
STARTED,
...
}
}
從這里命名這里可以看出，使用的是觀察者模式。也就是有觀察者和被觀察者。LifecycleOwner 是被觀察者，LifecycleObserver是觀察者。
可以想象這樣一個場景：人要過馬路看紅綠燈，紅綠燈就是被觀察者，人就是觀察者，紅綠燈狀態(tài)會發(fā)生變化，人需要根據(jù)變化做出改變。
添加一個 LifecycleObserver，當(dāng) LifecycleOwner 發(fā)生變化時會收到通知狀態(tài)。例如，如果 LifecycleOwner 處于 {@link State#STARTED} 狀態(tài)，則給定的觀察者將接收 {@link Event#ON_CREATE}、{@link Event#ON_START} 事件。
LifeCycle的簡單使用：
添加依賴
implementation 'androidx.appcompat:appcompat:1.2.0'
implementation "androidx.lifecycle:lifecycle-common:2.2.0"
implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"
implementation "androidx.lifecycle:lifecycle-runtime:2.2.0"
lifecycle調(diào)用addObserver() 傳入Observer 。
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.d("MainActivity","inner onCreate")
lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) {
Log.d("Observer","inner onCreate")
}
override fun onResume(owner: LifecycleOwner) {
Log.d("Observer","inner onResume")
}
override fun onDestroy(owner: LifecycleOwner) {
Log.d("Observer","inner onDestroy")
}
})
}
override fun onResume() {
super.onResume()
Log.d("MainActivity","inner onResume")
}
override fun onDestroy() {
super.onDestroy()
Log.d("MainActivity","inner onDestroy")
}
}
運(yùn)行后結(jié)果如下所示。隨著activity生命周期發(fā)生變化，會執(zhí)行DefaultLifecycleObserver 中重寫的函數(shù)。
這里的lifecycle實(shí)際是一個mLifecycleRegistry。因?yàn)镃omponentActivity 實(shí)現(xiàn)了LifecycleOwner接口，所以要重寫getLifecycle（）。
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-common/src/main/java/androidx/lifecycle/LifecycleOwner.java
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
MainActivity繼承自ComponentActivity ，因此能調(diào)用getLifecycle(),那么問題來了。
Android 是怎么做到當(dāng)給傳入一個觀察者之后，能執(zhí)行onCreate等生命周期同名函數(shù)的？
下面以ComponentActivity這個類為入口去分析。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
ContextAware,
LifecycleOwner,
...{
...
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
...
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
// Restore the Saved State first so that it is available to
// OnContextAvailableListener instances
mSavedStateRegistryController.performRestore(savedInstanceState);
mContextAwareHelper.dispatchOnContextAvailable(this);
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
}
執(zhí)行了private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
/**
* Creates a new LifecycleRegistry for the given provider.
* <p>
* You should usually create this inside your LifecycleOwner class's constructor and hold
* onto the same instance.
*
* @param provider The owner LifecycleOwner
*/
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
this(provider, true);
}
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
// 傳入 ComponentActivity這個LifecycleOwner，并使用弱引用
mLifecycleOwner = new WeakReference<>(provider);
//更新 androidx.lifecycle.Lifecycle.State 狀態(tài)
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
//后面再分析這個函數(shù)
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// observer轉(zhuǎn)換成ObserverWithState，存儲LifecycleEventObserver和State（androidx.lifecycle.Lifecycle.State）
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
...
}
在ComponentActivity的onCreate方法中，把生命周期的處理交給ReportFragment，代碼如下：
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-runtime/src/main/java/androidx/lifecycle/ReportFragment.java
public static void injectIfNeededIn(Activity activity) {
//API29及其以上，監(jiān)聽activity生命周期的邏輯
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
LifecycleCallbacks.registerIn(activity);
}
//API29以下，通過在activity添加一個空UI的Fragment，然后監(jiān)聽Fragment的生命周期就是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();
}
}
@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
//通過activity提供的接口，監(jiān)聽生命周期，是在API29才加入的接口
activity.registerActivityLifecycleCallbacks(new ReportFragment.LifecycleCallbacks());
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
//監(jiān)聽到相應(yīng)的生命周期，分發(fā)事件
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
//......其他事件
@Override
public void onActivityPrePaused(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE);
}
}
走到Activity.java的registerActivityLifecycleCallbacks中。
https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Activity.java
private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
new ArrayList<Application.ActivityLifecycleCallbacks>();
public void registerActivityLifecycleCallbacks(
@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
這個callback是哪里調(diào)用的呢？
直接點(diǎn)擊這個，在線查找。翻到activity中的部分可以看到如下所示。
這里點(diǎn)進(jìn)dispatchActivityPreStarted中去看下。
private void dispatchActivityPreStarted() {
getApplication().dispatchActivityPreStarted(this);
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPreStarted(this);
}
}
}
如果對activity啟動流程有一定的了解的話，就知道啟動過程中會調(diào)用activity.performStart()。
而performStart中調(diào)用了dispatchActivityPreStarted。
final void performStart(String reason) {
dispatchActivityPreStarted();
...
}
因此，activity啟動后，調(diào)用了ReportFragment中重寫的 onActivityCreated，onActivityPostCreated，onActivityPostStarted等回調(diào)函數(shù)。
調(diào)用onActivityPostCreated，從而執(zhí)行 dispatch(activity, Lifecycle.Event.ON_CREATE);
。
最終會走到handleLifecycleEvent。
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-runtime/src/main/java/androidx/lifecycle/ReportFragment.java
@SuppressWarnings("deprecation")
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);
}
}
}
getLifecycle()返回的是LifecycleRegistry，然后走到handleLifecycleEvent。
簡單小結(jié)：
通過在ReportFragment中調(diào)用activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());，將LifecycleCallbacks傳入Activity，從而使得activty啟動的時候，調(diào)用onActivityPostCreated，然后走到observer.dispatchEvent(lifecycleOwner, event);，最終走到handleLifecycleEvent（LifecycleRegistry中）。
/**
* Sets the current state and notifies the observers.
* <p>
* Note that if the {@code currentState} is the same state as the last call to this method,
* calling this method has no effect.
*
* @param event The event that was received
*/
// 設(shè)置當(dāng)前狀態(tài)并通知觀察者
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
private void moveToState(State next) {
...
mHandlingEvent = true;
sync();
mHandlingEvent = false;
...
}
private void sync() {
...
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
...
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
...
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
...
observer.dispatchEvent(lifecycleOwner, event);
...
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
...
observer.dispatchEvent(lifecycleOwner, event);
...
}
observer.dispatchEvent(lifecycleOwner, event);中的observer是哪里來的？
LifecycleRegistry.java這個類中的函數(shù)addObserver的時候傳入的observer。
在調(diào)用addObserver傳入LifecycleObserver添加觀察者的時候 ，LifecycleObserver會被封裝成
ObserverWithState放到mObserverMap中，需要用的時候再取出來。
addObserver這里也會走到dispatchEvent(LifecycleOwner owner, Event event)中。
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//確保在主線程運(yùn)行
//當(dāng)mEnforceMainThread為true時，必須是在主線程調(diào)用，否則拋出異常
enforceMainThreadIfNeeded("addObserver");
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// observer轉(zhuǎn)換成ObserverWithState，存儲LifecycleEventObserver和State
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//以observer為key，將observer和statefulObserver存到mObserverMap中
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
...
//計(jì)算目標(biāo)狀態(tài)，目的是從初始化狀態(tài)遍歷到當(dāng)前實(shí)際狀態(tài)，然后把每一個狀態(tài)的事件分發(fā)
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
//分發(fā)事件
statefulObserver.dispatchEvent(lifecycleOwner, 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) {
...
mLifecycleObserver.onStateChanged(owner, event);
...
}
}
dispatchEvent這里重點(diǎn)關(guān)注下mLifecycleObserver.onStateChanged(owner, event);
mLifecycleObserver是通過Lifecycling.lifecycleEventObserver(observer)轉(zhuǎn)換而來的一個LifecycleEventObserver 對象。這個observer就是前面MainActivity中addObserver傳入的observer。LifecycleEventObserver，生命周期事件觀察者，一個接口。
public interface LifecycleEventObserver extends LifecycleObserver {
/**
* Called when a state transition event happens.
*
* @param source The source of the event
* @param event The event
*/
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
哪里重寫了這個回調(diào)并傳入？
答案在Lifecycling.lifecycleEventObserver(observer)里。
@NonNull
@SuppressWarnings("deprecation")
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;
}
//如果觀察者是通過實(shí)現(xiàn)LifecycleObserver，并用注解 @OnLifecycleEvent修飾方法這樣的方式實(shí)現(xiàn)的，
//就走下面的邏輯，會用反射實(shí)現(xiàn)
//因?yàn)闀玫椒瓷?，所以會有性能問題，不推薦使用
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
for (int i = 0; i < constructors.size(); i++) {
adapters[i] = createGeneratedAdapter(constructors.get(i), object);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
}
這里先判斷observer的類型，然后轉(zhuǎn)換成FullLifecycleObserverAdapter。這里面重寫了onStateChanged。
class FullLifecycleObserverAdapter implements LifecycleEventObserver {
private final FullLifecycleObserver mFullLifecycleObserver;
private final LifecycleEventObserver mLifecycleEventObserver;
FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
LifecycleEventObserver lifecycleEventObserver) {
mFullLifecycleObserver = fullLifecycleObserver;
mLifecycleEventObserver = lifecycleEventObserver;
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull 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;
}
....
}
}
dispatchEvent的mLifecycleObserver.onStateChanged ，實(shí)際調(diào)用的是FullLifecycleObserverAdapter 中的onStateChanged。
//LifecycleRegistry.java
void dispatchEvent(LifecycleOwner owner, Event event) {
...
mLifecycleObserver.onStateChanged(owner, event);
...
}
當(dāng)有event事件分發(fā)下來，例如分發(fā)ON_CREATE， 那么會走到mFullLifecycleObserver.onCreate(source);
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-common/src/main/java/androidx/lifecycle/FullLifecycleObserver.java
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);
}
FullLifecycleObserver 只是一個接口，沒有真正的函數(shù)實(shí)現(xiàn)，實(shí)際函數(shù)實(shí)現(xiàn)在哪里？
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.d("MainActivity","inner onCreate")
lifecycle.addObserver(object : DefaultLifecycleObserver {
override fun onCreate(owner: LifecycleOwner) {
Log.d("Observer","inner onCreate")
}
override fun onResume(owner: LifecycleOwner) {
Log.d("Observer","inner onResume")
}
override fun onDestroy(owner: LifecycleOwner) {
Log.d("Observer","inner onDestroy")
}
})
}
override fun onResume() {
super.onResume()
Log.d("MainActivity","inner onResume")
}
override fun onDestroy() {
super.onDestroy()
Log.d("MainActivity","inner onDestroy")
}
}
前面MainActivity 中使用了匿名內(nèi)部類DefaultLifecycleObserver ，DefaultLifecycleObserver 繼承FullLifecycleObserver 。
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
...
}
所以 mFullLifecycleObserver.onCreate(source);的具體實(shí)現(xiàn)是在新建工程的自定義類MainActivity中 ，也就是
// MainActivity
override fun onCreate(owner: LifecycleOwner) {
Log.d("Observer","inner onCreate")
}
使用lifecycler的情況下，activity啟動簡單流程調(diào)用如下：
performCreate
-> dispatchActivityPostCreated()
-> onActivityPostCreated
-> dispatch(activity, Lifecycle.Event.ON_CREATE)
-> handleLifecycleEvent(event)
-> dispatchEvent(lifecycleOwner, event)
-> mLifecycleObserver.onStateChanged(owner, event)
-> mFullLifecycleObserver.onCreate(source)
-> DefaultLifecycleObserver中自己重寫的override fun onCreate(owner: LifecycleOwner)
上面這部分就是當(dāng)生命周期發(fā)生變化時的事件分發(fā)流程。接下來，著重來看下Lifecycle這個類中的State 。
https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-common/src/main/java/androidx/lifecycle/Lifecycle.java
@SuppressWarnings("WeakerAccess")
public enum State {
/**
* Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
* any more events. For instance, for an {@link android.app.Activity}, this state is reached
* <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
*/
DESTROYED,
/**
* Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
* the state when it is constructed but has not received
* {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
*/
INITIALIZED,
/**
* Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
* <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
* </ul>
*/
CREATED,
/**
* Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached in two cases:
* <ul>
* <li>after {@link android.app.Activity#onStart() onStart} call;
* <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
* </ul>
*/
STARTED,
/**
* Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
* is reached after {@link android.app.Activity#onResume() onResume} is called.
*/
RESUMED;
/**
* Compares if this State is greater or equal to the given {@code state}.
*
* @param state State to compare with
* @return true if this State is greater or equal to the given {@code state}
*/
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
在此之前，先了解下狀態(tài)模式的架構(gòu)和使用枚舉實(shí)現(xiàn)狀態(tài)機(jī)。了解狀態(tài)模式的引入是為了解決什么問題，以及狀態(tài)模式的架構(gòu)，以及狀態(tài)機(jī)之后，才能更清晰地理解Lifecycle的設(shè)計(jì)。
“人有悲歡離合，月有陰晴圓缺”，包括人在內(nèi)，很多事物都具有多種狀態(tài)，而且在不同狀態(tài)下會具有不同的行為，這些狀態(tài)在特定條件下還將發(fā)生相互轉(zhuǎn)換。就像水，它可以凝固成冰，也可以受熱蒸發(fā)后變成水蒸汽，水可以流動，冰可以雕刻，蒸汽可以擴(kuò)散。我們可以用UML狀態(tài)圖來描述H2O的三種狀態(tài)，
在軟件系統(tǒng)中，有些對象也像水一樣具有多種狀態(tài)，這些狀態(tài)在某些情況下能夠相互轉(zhuǎn)換，而且對象在不同的狀態(tài)下也將具有不同的行為。
不使用狀態(tài)模式去定義一個賬戶類，并執(zhí)行存取款操作的話，代碼如下所示。
class Account {
private String state; //狀態(tài)
private int balance; //余額
......
//存款操作
public void deposit() {
//存款
stateCheck();
}
//取款操作
public void withdraw() {
if (state.equalsIgnoreCase("NormalState") || state.equalsIgnoreCase("OverdraftState ")) {
//取款
stateCheck();
}
else {
//取款受限
}
}
//計(jì)算利息操作
public void computeInterest() {
if(state.equalsIgnoreCase("OverdraftState") || state.equalsIgnoreCase("RestrictedState ")) {
//計(jì)算利息
}
}
//狀態(tài)檢查和轉(zhuǎn)換操作
public void stateCheck() {
if (balance >= 0) {
state = "NormalState";
}
else if (balance > -2000 && balance < 0) {
state = "OverdraftState";
}
else if (balance == -2000) {
state = "RestrictedState";
}
else if (balance < -2000) {
//操作受限
}
}
......
}
擁有一個較為復(fù)雜的stateCheck()方法，包含大量的if…else if…else…語句用于進(jìn)行狀態(tài)轉(zhuǎn)換，不易于維護(hù)（if else寫多了真的很難維護(hù)）。
使用狀態(tài)模式可以解決這個問題。
狀態(tài)模式定義如下：
狀態(tài)模式(State Pattern)：允許一個對象在其內(nèi)部狀態(tài)改變時改變它的行為，對象看起來似乎修改了它的類。其別名為狀態(tài)對象(Objects for States)，狀態(tài)模式是一種對象行為型模式。
在狀態(tài)模式中引入了抽象狀態(tài)類和具體狀態(tài)類
https://blog.csdn.net/lovelion/article/details/8523062
環(huán)境類維持一個對抽象狀態(tài)類的引用，通過setState()方法可以向環(huán)境類注入不同的狀態(tài)對象，再在環(huán)境類的業(yè)務(wù)方法中調(diào)用狀態(tài)對象的方法，典型代碼如下所示：
class Context {
private State state; //維持一個對抽象狀態(tài)對象的引用
private int value; //其他屬性值，該屬性值的變化可能會導(dǎo)致對象狀態(tài)發(fā)生變化
//設(shè)置狀態(tài)對象
public void setState(State state) {
this.state = state;
}
public void request() {
//其他代碼
state.handle(); //調(diào)用狀態(tài)對象的業(yè)務(wù)方法
//其他代碼
}
}
……
public void changeState() {
//判斷屬性值，根據(jù)屬性值進(jìn)行狀態(tài)轉(zhuǎn)換
if (value == 0) {
this.setState(new ConcreteStateA());
}
else if (value == 1) {
this.setState(new ConcreteStateB());
}
......
}
……
但是這種實(shí)現(xiàn)方式會會增加過多的狀態(tài)對象依賴，有一種更好的實(shí)現(xiàn)方法，那就是使用枚舉來實(shí)現(xiàn)狀態(tài)機(jī)。
先來看看什么是狀態(tài)機(jī)。
https://cloud.tencent.com/developer/article/1870480
狀態(tài)機(jī)
一個狀態(tài)機(jī)可能是有限狀態(tài)機(jī)或者有限自動化，它是一個用來構(gòu)造抽象機(jī)器的計(jì)算模型。
這些機(jī)器在特定時間節(jié)點(diǎn)只能有一種狀態(tài)。一種狀態(tài)到另外一種狀態(tài)的變化叫做變更（transition）。
狀態(tài)模式也是知名的GoF的32種設(shè)計(jì)模式之一。狀態(tài)機(jī)是從數(shù)學(xué)中借鑒而來的概念。
用枚舉實(shí)現(xiàn)狀態(tài)機(jī)
通過枚舉實(shí)現(xiàn)狀態(tài)機(jī)的核心是，我們不需要明確設(shè)置狀態(tài)，而是通過邏輯讓狀態(tài)流轉(zhuǎn)到下一個狀態(tài)
枚舉實(shí)現(xiàn)狀態(tài)機(jī)的優(yōu)勢
通過類或者接口方式實(shí)現(xiàn)狀態(tài)機(jī)代碼量非常大而且不容易維護(hù)。
而Java枚舉則是一種簡化的形式。
下面來看看Lifecycle 中 的 enum Event 和 enum State。
https://segmentfault.com/a/1190000016443108
https://segmentfault.com/a/1190000016443108
State和Event，這也是貫穿整個Lifecycle的兩個概念：狀態(tài)和事件。
Lifecycle將Activity的生命周期函數(shù)對應(yīng)成State，生命周期改變，會造成State改變，而State變化將觸發(fā)Event事件，從而被LifecycleObser接收。
State：狀態(tài)，是Lifecycle中對應(yīng)Activity生命周期的一種狀態(tài)標(biāo)識，從圖中可以看到，它有INITIALIZED、DESTROYED、CREATED、STARTED、RESUMED這5中狀態(tài)。
- INITIALIZED：對應(yīng)Activity的onCreate之前的生命周期
- DESTROYED：對應(yīng)Activity的onDestroy
- CREATED：對應(yīng)Activity的onCreate到onStop之間的生命周期
- STARTED：對應(yīng)Activity的onStart到onPause之間的生命周期
- RESUMED：對應(yīng)Activity的onResume
Event：事件，當(dāng)State發(fā)生變化時，Lifecycle會向已注冊的LifecycleObserver發(fā)送事件，例如：當(dāng)State從INITIALIZED變化到CREATED時，就會發(fā)出ON_CREATE事件。
以下面這個問題為引，加深下對狀態(tài)機(jī)的理解。
https://segmentfault.com/a/1190000016443108
Event事件是如何分發(fā)到LifecycleObserver的？
LifecycleRegistry在收到handleLifecycleEvent()后，內(nèi)部調(diào)用moveToState()方法，改變State值，每一次State值改變，都會調(diào)用LifecycleObserver.onStateChanged()方法將Event分發(fā)到LifecycleObserver。
最后，以一張流程圖來結(jié)尾加深下印象（雖然部分類由于版本問題有差異，但是大致是這樣的）。
參考鏈接：
官方文檔：
Android Jetpack架構(gòu)組件（三）帶你了解Lifecycle（原理篇）
利用Java枚舉實(shí)現(xiàn)簡單的狀態(tài)機(jī)
使用枚舉實(shí)現(xiàn)狀態(tài)機(jī)來優(yōu)雅你的狀態(tài)變更邏輯
處理對象的多種狀態(tài)及其相互轉(zhuǎn)換——狀態(tài)模式（一）
處理對象的多種狀態(tài)及其相互轉(zhuǎn)換——狀態(tài)模式（二）
https://developer.android.com/topic/libraries/architecture/lifecycle?hl=zh-cn
啃源碼之--Lifecycle
一文搞懂Android JetPack組件原理之Lifecycle、LiveData、ViewModel與源碼分析技巧
從源碼看 Jetpack（1）- Lifecycle 源碼詳解
Android Jetpack架構(gòu)組件（三）帶你了解Lifecycle（原理篇）
Android-Lifecycle超能解析-生命周期的那些事兒
