提綱
- Lifecycle是什么
- 怎么使用Lifecycle觀察宿主狀態(tài)
- LifecycleOwner垛叨、Lifecycle嗽元、LifecycleRegistry相關(guān)說明
- Lifecycle在Fragment中是如何實現(xiàn)的
- Lifecycle在Activity中是如何實現(xiàn)的
- Lifecycle是如何分發(fā)宿主狀態(tài)的
一、Lifecycle是什么
具備感知
宿主生命周期能力的組件佩谷，Jetpack的核心組件
二监嗜、怎么使用Lifecycle觀察宿主狀態(tài)
// eg:1
class CustomObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(){
// do someting
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart() {}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun onStop() {}
···
}
// eg:2
class CustomObserver : LifecycleEventObserver{
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when(event){
Lifecycle.Event.ON_CREATE -> {
// do someting
}
Lifecycle.Event.ON_START -> {
// // do someting
}
···
}
}
}
······
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val observer = CustomObserver()
lifecycle.addObserver(observer)
}
}
三桐猬、LifecycleOwner课幕、Lifecycle乍惊、LifecycleRegistry相關(guān)說明
3.1 LifecycleOwner、Lifecycle撬碟、LifecycleRegistry的關(guān)系
LifecycleOwner：Activity呢蛤、Fragment 都實現(xiàn)了該接口其障，用以聲明它是一個能夠提供生命周期事件的宿主励翼；同時必須復寫getLifecycle()方法提供一個Lifecycle對象汽抚；Lifecycle：是一個抽象類造烁，里面定義了兩個枚舉惭蟋，State:宿主的狀態(tài)告组，Event :需要分發(fā)的事件的類型public enum State { DESTROYED,// LifecycleOwner的已銷毀狀態(tài)。此事件之后驼卖，此生命周期將不再分派任何事件 for >an Act怎囚，onDestory之前 INITIALIZED, // LifecycleOwner的初始化狀態(tài) for an Act考婴，not received onCreate CREATED, // LifecycleOwner的created狀態(tài) STARTED, // LifecycleOwner的started狀態(tài) RESUMED; // LifecycleOwner的resumed狀態(tài) /** * 比較當前State與給定的State的大小 */ public boolean isAtLeast(@NonNull Lifecycle.State state) { return compareTo(state) >= 0; } } public enum Event { ON_CREATE, // onCreate事件 ON_START, // onStart事件 ON_RESUME,// onResume事件 ON_PAUSE,//onPause事件 ON_STOP, //onStop事件 ON_DESTROY, //onDestroy事件 ON_ANY // 可用于匹配所有事件 } 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); }圖3.1.1 宿主生命周期與宿主狀態(tài)的對應關(guān)系
LifecycleRegistry:是Lifecycle的唯一實現(xiàn)類，負責添加 Observer考杉，以及分發(fā)宿主狀態(tài)事件
3.2 關(guān)于LifecycleRegistry中相關(guān)方法說明
3.2.1 void addObserver(LifecycleObserver)添加觀察者
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
// 如果mState不為DESTROYED的狀態(tài)崇棠，重置mState狀態(tài)為INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
// 將observer和state包裝為一個ObserverWithState對象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
// FastSafeIterableMap繼承自SafeIterableMap(維護一個雙向鏈表)
// FastSafeIterableMap內(nèi)部使用HashMap存儲
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
// 禁止重復add
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
// while循環(huán)枕稀，將observer的狀態(tài)和宿主的當前狀態(tài)對齊(DESTORYED < INIT < CREATED < STARTED < RESUMED)
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//向觀察者分發(fā)宿主生命周期事件的方法萎坷，想方設(shè)法把Observer適配成LifecycleEventObserver(目的是為了統(tǒng)一事件的分發(fā)形式)食铐，調(diào)用其LifecycleEventObserver.onStateChanged()方法完成分發(fā)
//假設(shè)是在宿主的onresume犯法內(nèi)注冊的該觀察者
//第一次：分發(fā)on_Create事件，觀察者狀態(tài)INIT->CREATED
//第二次：分發(fā)on_Start事件寞秃，觀察者狀態(tài)CREATED->STARTED
//第三次：分發(fā)on_Resume事件春寿，觀察者狀態(tài)STARTED->RESUMED ？忽孽？绑改？？兄一？
//第三次分發(fā)on_Resume是通過handlerLifecycle()最終通過forwardPass()方法分發(fā)的
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate厘线、
// 重新計算targetState，同級觀察者可能已經(jīng)重新計算
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
// 同步觀察者到宿主當前狀態(tài)
sync();
}
mAddingObserverCounter--;
}
3.2.2 void sync() 完成事件的分發(fā)和觀察者狀態(tài)的同步
// 完成事件的分發(fā)和觀察者狀態(tài)的同步
private void sync() {
while (!isSynced()) {
//如果宿主當前轉(zhuǎn)態(tài) 小于 mObserverMap集合中最先添加的那個觀察者的狀態(tài)
//則說明宿主可能發(fā)生了狀態(tài)回退出革，比如當前是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);
}
//如果宿主當前轉(zhuǎn)態(tài) 大于 mObserverMap集合中最先添加的那個觀察者的狀態(tài)
//則說明宿主可能發(fā)生了狀態(tài)升級耳璧，比如當前是STARTED狀態(tài)攀隔，執(zhí)行了onResume則前進到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);
}
}
}
3.2.3 void handleLifecycleEvent (Lifecycle.Event event)設(shè)置當前狀態(tài)并通知觀察者
/**
* 設(shè)置當前狀態(tài)并通知觀察者
*/
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next; // 設(shè)置當前狀態(tài)
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
// we will figure out what to do on upper level.
return;
}
mHandlingEvent = true;
sync(); // 通知觀察者
mHandlingEvent = false;
}
四檬洞、 Lifecycle在Fragment中的實現(xiàn)
使用 Fragment 實現(xiàn) Lifecycle 广料，在各個生命周期方法內(nèi)利用LifecycleRegistry分發(fā)相應的事件給每個觀察者，以實現(xiàn)生命周期觀察的能力：
public class Fragment implements ···, LifecycleOwner,···{
LifecycleRegistry mLifecycleRegistry;
@Override
@NonNull
public Lifecycle getLifecycle() {
return 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();
}
}
}
});
}
}
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState);
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
onDestroy();
}
}
五、 Lifecycle在Activity中的實現(xiàn)
Activity 實現(xiàn) Lifecycle 是通過向 Activity上添加一個無UI的ReportFragment用以報告生命周期的變化,目的是為了兼顧不是繼承自 AppCompactActivity 的場景.
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner, ···{
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
}
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
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();
}
}
// 最終還是調(diào)用 handleLifecycleEvent() -> moveToState() -> sync()体啰，實現(xiàn)設(shè)置狀態(tài)和通知觀察者
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);
}
}
}
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
@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);
}
}
六仅偎、 Lifecycle是如何分發(fā)宿主狀態(tài)的
/**
* 狀態(tài)升級
*/
private void forwardPass(LifecycleOwner lifecycleOwner) {
// 鏈表正序
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
// 比較當前observer的狀態(tài)和宿主當前狀態(tài)
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
// 分發(fā)宿主事件到observer
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
/**
* 狀態(tài)回退
*/
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();
// 比較當前observer的狀態(tài)和宿主當前狀態(tài)
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
// 分發(fā)宿主事件到observer
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
static class ObserverWithState {
State mState;
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);
// 回調(diào)當前宿主狀態(tài)到observer中
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
圖3.5.1
