網站首頁 編程語言 正文
提綱
1,什么是Lifecycle?
2,如何使用Lifecycle?
3,LifecycleOwner,Lifecycle,LifecycleObserver之間是什么關系?
3,Activity是如何實現Lifecycle的?
4,Fragment是如何實現Lifecycle的?
5,Lifecycle是如何下發宿主生命周期給觀察者的?
什么是Lifecycle
Lifecycle是Jetpack組件庫中的架構組件,顧名思義就是一個生命周期組件,它可感知宿主的生命周期,并根據生命周期反推出生命周期所屬的狀態下發給觀察者。
如何使用Lifecycle
1,實現其生命周期回調接口,成為生命周期觀察者
2,在Activity/Fragment中獲取Lifecycle實例并添加觀察者
3,實例代碼如下,個人比較推薦第一種方式,第二種方式比較繁瑣,需要在方法上通過注解來表明想要觀察的生命周期事件
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
//訂閱生命周期
lifecycle.addObserver(MyLifecycleEventObserver())
lifecycle.addObserver(MyLifecycleObserver())
}
/**
* 方式一(個人比較推薦)
*/
class MyLifecycleEventObserver : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
when (event) {
Lifecycle.Event.ON_CREATE -> println("onCreate")
Lifecycle.Event.ON_START -> println("onStart")
Lifecycle.Event.ON_RESUME -> println("onResume")
Lifecycle.Event.ON_PAUSE -> println("onPause")
Lifecycle.Event.ON_STOP -> println("onStop")
Lifecycle.Event.ON_DESTROY -> println("onDestroy")
}
}
}
/**
* 方式二
*/
class MyLifecycleObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(event: Lifecycle.Event) {
println("onCreate")
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart(event: Lifecycle.Event) {
println("onStart")
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume(event: Lifecycle.Event) {
println("onResume")
}
}
}
關系梳理
LifecycleOwner,Lifecycle,LifecycleObserver之間是什么關系?
1,LifecycleOwner:生命周期持有者,我們的Activity/Fragment都實現了這個接口并重寫了它的抽象方法getLicycle()返回一個Licycle實例。
2,Lifecycle:LifecycleRegsitry是它的唯一實現類,主要用來負責注冊觀察者,下發宿主狀態給觀察者
3,LicycleObserver:是一個接口,主要用來接收宿主的生命周期狀態,實現該接口即可成為一個生命周期觀察者
4,他們之間的持有關系如下圖:
Activity是如何實現Lifecycle的
CompatActivity
如果我們的Activity是繼承自CompatActivity,那么CompatActivity需要在Activity上添加一個ReportFragment來實現生命周期下發
(1)在CompatActivity中創建LifecycleRegistry類型的成員變量mLifecycleRegistry
(2)在CompatActivity的onCreate()方法中往Activity中添加一個ReportFragment來下發命周期
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
//創建Lifecycle實例
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
//往Activity添加一個ReportFragment來達到下發生命周期的目的
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
}
(3) 將Fragment與Activity進行綁定,添加到Activity中,用于感知Activity生命周期變化
(4)當Activity生命周期發生變化,對應的生命周期回調方法被調用,下發生命周期給觀察者
public class ReportFragment extends Fragment {
public static void injectIfNeededIn(Activity activity) {
//往Activity中存放一個ReportFragment
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();
}
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
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);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
/**
* 下發生命周期事件
*/
private void dispatch(Lifecycle.Event event) {
//獲取Activity的Lifecycle實例,下發生命周期事件
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);
}
}
}
}
AppCompatActivity
如果我們的Activity是繼承自AppCompatActivity ,不需要往Activity中添加一個ReportFragment來感知生命周期并下發生命周期事件,AppCompatActivity 繼承自FragmentActivity,下發生命周期事件都在FragmentActivity的生命周期回調方法中進行
(1)創建LifecycleRegistry類型的變量mFragmentLifecycleRegistry
(2)在其生命周期回調方法中調用mFragmentLifecycleRegistry的handlerLifecycleEvent()方法進行下發生命周期事件
public class FragmentActivity extends ComponentActivity implements
ActivityCompat.OnRequestPermissionsResultCallback,
ActivityCompat.RequestPermissionsRequestCodeValidator {
//創建Lifecycle實例
final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
//下發生命周期事件
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
mFragments.dispatchDestroy();
//下發生命周期事件
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}
@Override
protected void onPause() {
super.onPause();
mResumed = false;
mFragments.dispatchPause();
//下發生命周期事件
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
protected void onResumeFragments() {
//下發生命周期事件
mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
mFragments.dispatchResume();
}
}
Fragment是如何實現Lifecycle的
其實Fragment實現Lifecycle,下發其生命周期的操作跟AppCompatActivity 是一樣的套路,在其生命周期回調方法中進行生命周期事件下發
(1)創建Fragment時調用initLifecycle()方法給LifecycleRegistry類型的mLifecycleRegistry變量賦值
(2)在其生命周期回調方法中調用mLifecycleRegistry的handlerLifecycleEvent()方法下發生命周期事件給觀察者
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, SavedStateRegistryOwner {
LifecycleRegistry mLifecycleRegistry;
public Fragment() {
initLifecycle();
}
private void initLifecycle() {
//創建Lifecycle實例
mLifecycleRegistry = new LifecycleRegistry(this);
}
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState);
//下發生命周期事件給觀察者
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
//下發生命周期事件給觀察者
mChildFragmentManager.dispatchStart();
}
void performResume() {
onResume();
//下發生命周期事件給觀察者
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
}
Lifecycle是如何下發宿主生命周期給觀察者的
(1)在我們調用Lifecycle的addObserver()方法時就已經開始下發生命周期事件了,接下來讓我們先從addObserver()這個入口看看其實現邏輯,大致邏輯如下
public class LifecycleRegistry extends Lifecycle {
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//首次添加觀察者,如果宿主狀態不是DESTROYED,那么觀察者初始狀態都是INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//把傳進去的生命周期觀察者以及初始狀態包裝成ObserverWithState對象
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//把包裝好的ObserverWithState對象存放到觀察者集合中,如果此前已經添加過則會返回此前添加的值,否則返回null
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//判斷此前是否添加過,如果添加過則直接結束方法
if (previous != null) {
return;
}
//獲取宿主實例
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
//計算觀察者的目標狀態
State targetState = calculateTargetState(observer);
//循環比對觀察者的狀態和宿主的狀態,如果沒有對齊則下發對應的生命周期事件
//拿觀察者的狀態和宿主的狀態做比較 如果小于0代表狀態還沒有對齊,需要繼續下發生命周期狀態給觀察者
//假設是在Activity的onResume()方法中注冊的觀察者,那么就需要給觀察者下發onCreate,onStart,onResume這些事件
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
}
}
(2)分析完addObserver()做了哪些事,那么我們再來分析下handlerLifecycleEvent()方法做了什么事
public class LifecycleRegistry extends Lifecycle {
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//根據生命周期事件推算出其狀態
State next = getStateAfter(event);
//移動到新狀態
moveToState(next);
}
private void moveToState(State next) {
//如果當前狀態和新狀態相等 結束方法
if (mState == next) {
return;
}
//記錄新狀態
mState = next;
//如果當前正在下發生命周期事件 或 當前正在添加觀察者 結束方法
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
return;
}
//同步新狀態給觀察者
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
private void sync() {
//獲取宿主實例
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//停止循環的條件是已經同步狀態完成 或 沒有觀察者
while (!isSynced()) {
mNewEventOccurred = false;
//獲取觀察者集合中最先添加的那個元素 拿當前狀態和觀察者狀態作比較 判斷當前是不是向后移動狀態 STARTED -> ON_STOP
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
//獲取觀察者集合中最新添加的那個元素 拿當前狀態和觀察者狀態作比較 判斷當前是不是向前移動狀態 STARTED -> ON_RESUME
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
/**
* 向前移動狀態
*/
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();
//拿觀察者的狀態和宿主的狀態做比較 如果小于0代表狀態還沒有對齊
//假設當前宿主在RESUMED狀態 觀察者在CREATED狀態 則需要下發:ON_START,ON_RESUME生命周期事件 需要循環兩次
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
//根據觀察者狀態反推向前移動事件 下發生命周期事件
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
/**
* 通過觀察者狀態反推向前移動事件
*/
private static Event upEvent(State state) {
switch (state) {
case INITIALIZED:
case DESTROYED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
case RESUMED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
/**
* 向后移動狀態
*/
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();
//拿觀察者的狀態和宿主的狀態做比較 如果大于0代表狀態還沒有對齊
//假設當前觀察者在RESUMED狀態 宿主在DESTROYED狀態 那么需要下發:ON_PAUSE,ON_STOP,ON_DESTROY這些生命周期事件 循環三次
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
//根據觀察者狀態反推出向后移動事件
Event event = downEvent(observer.mState);
pushParentState(getStateAfter(event));
//下發該生命周期事件給觀察者
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
/**
* 通過觀察者狀態反推向后移動的事件
*/
private static Event downEvent(State state) {
switch (state) {
case INITIALIZED:
throw new IllegalArgumentException();
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
case DESTROYED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
}
(3)接下來我們看看ObserverWitchState的dispatchEvent()方法是如何下發生命周期事件給觀察者的,我們知道在調用Lifecycle的addObserver()方法時就把我們傳進去的LifecycleObserver封裝成了一個ObserverWitchState對象,并存放到生命周期觀察者集合中
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);
//調用生命周期觀察者的onStateChanged()方法通知生命周期觀察者生命周期發生變化
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
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);
}
(4)到此結束,希望對讀者有所幫助
原文鏈接:https://blog.csdn.net/qq_42359647/article/details/125866374
相關推薦
- 2022-07-21 IC設計中glitch free時鐘選擇器的設計過程
- 2022-04-18 create-react-app 中支持sass,怎么搞?
- 2022-10-20 Swift泛型Generics淺析講解_Swift
- 2022-08-15 python?time模塊時間戳?與?結構化時間詳解_python
- 2023-07-22 linux查看進程的啟動路徑:ll /proc/PID
- 2022-10-25 maven方式創建spring項目-eclipse篇
- 2022-08-19 python模塊和函數幫助文檔快速查看方法示例_python
- 2022-06-18 Android實現背景圖滑動變大松開回彈效果_Android
- 最近更新
-
- window11 系統安裝 yarn
- 超詳細win安裝深度學習環境2025年最新版(
- Linux 中運行的top命令 怎么退出?
- MySQL 中decimal 的用法? 存儲小
- get 、set 、toString 方法的使
- @Resource和 @Autowired注解
- Java基礎操作-- 運算符,流程控制 Flo
- 1. Int 和Integer 的區別,Jav
- spring @retryable不生效的一種
- Spring Security之認證信息的處理
- Spring Security之認證過濾器
- Spring Security概述快速入門
- Spring Security之配置體系
- 【SpringBoot】SpringCache
- Spring Security之基于方法配置權
- redisson分布式鎖中waittime的設
- maven:解決release錯誤:Artif
- restTemplate使用總結
- Spring Security之安全異常處理
- MybatisPlus優雅實現加密?
- Spring ioc容器與Bean的生命周期。
- 【探索SpringCloud】服務發現-Nac
- Spring Security之基于HttpR
- Redis 底層數據結構-簡單動態字符串(SD
- arthas操作spring被代理目標對象命令
- Spring中的單例模式應用詳解
- 聊聊消息隊列,發送消息的4種方式
- bootspring第三方資源配置管理
- GIT同步修改后的遠程分支