| Markdown版本筆記 | 我的GitHub首頁 | 我的博客 | 我的微信 | 我的郵箱 |
|---|---|---|---|---|
| MyAndroidBlogs | baiqiantao | baiqiantao | bqt20094 | baiqiantao@sina.com |
Lifecycle Activity和Fragment生命周期感知組件 LifecycleObserver MD
目錄
簡介
相關的幾個接口和類
LifecycleObserver
LifecycleOwner
Lifecycle
LifecycleRegistry
使用案例
LifecycleObserver 的幾種實現方式
LifecycleObserver 接口
GenericLifecycleObserver 接口
FullLifecycleObserver 接口
DefaultLifecycleObserver 接口
在 Activity 中使用
在 Fragment 中使用
簡介
官方文檔
官方公眾號介紹文章：正式發布 Android 架構組件 1.0 穩定版 | 附帶中文介紹視頻
我們在處理Activity或者Fragment組件的生命周期相關時，不可避免會遇到這樣的問題：
我們在Activity的onCreate()中初始化某些成員，比如MVP架構中的Presenter，或者AudioManager、MediaPlayer等，然后在onStop中對這些成員進行對應處理，並在onDestroy中釋放這些資源。
這是很常見的情形，按照通常的做法，我們需要在Activity或者Fragment中的每個生命周期方法中都要調用一次IPresenter等成員中定義的相應的方法。我們可能覺得這沒什么，但是其實這些完全就是模板代碼，其本身往往沒有任何意義，這不僅浪費我們的時間，更讓我們的代碼臃腫了很多，於是Lifecycle組件就誕生了。
以下內容是對官方文檔的翻譯：
生命周期感知組件
[Lifecycle-aware components]執行操作[perform actions]以響應另一個組件(例如 Activity 或 Fragment)的生命周期狀態的更改。這些組件可幫助您生成更易於組織[better-organized]且通常更輕量級[lighter-weight]的代碼，並且這些代碼更易於維護。一種常見的模式是，在 Activity 或 Fragment 的生命周期方法中實現依賴組件的操作
[the actions of the dependent components]。 但是，這種模式導致代碼組織不良[poor organization]以及錯誤的增加。通過使用生命周期感知組件，您可以將依賴組件的代碼移出生命周期方法、並移入組件本身。
android.arch.lifecycle包提供了類和接口，使您可以構建生命周期感知組件，這些組件可以根據 Activity 或 Fragment 的當前生命周期狀態自動調整其行為。Android框架中定義的大多數應用程序組件都附加了生命周期。生命周期由操作系統或流程中運行的框架代碼所管理。它們是Android工作原理的核心，您的應用程序必須尊重它們。 不這樣做可能會觸發內存泄漏甚至應用程序崩潰。
android.arch.lifecycle 包提供了類和接口，可幫助您以彈性和隔離的方式
[resilient and isolated way]解決這些問題。
相關的幾個接口和類
LifecycleObserver
Lifecycle 觀察者
Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on OnLifecycleEvent annotated methods.
實現該接口的類，可以通過被 LifecycleOwner 類中的 Lifecycle 對象的 addObserver(LifecycleObserver o) 方法注冊，被注冊后，LifecycleObserver 便可以觀察 LifecycleOwner 的生命周期事件。
public interface LifecycleObserver {} //此接口沒有聲明任何方法LifecycleOwner
Lifecycle 持有者
A class that has an Android lifecycle. These events can be used by custom components to handle lifecycle changes without implementing any code inside the Activity or the Fragment.
如 Activity 或 Fragment。實現該接口的類持有 Lifecycle 對象。
持有 Lifecycle 有什么作用呢？
作用是在將 LifecycleOwner 對應的生命周期事件傳遞給內部的 Lifecycle 對象去處理，於是其生命周期的改變便可被 Lifecycle 所注冊的觀察者 LifecycleObserver 觀察到並觸發其對應的事件。
public interface LifecycleOwner {
Lifecycle getLifecycle();
}class FragmentActivity extends SupportActivity
class SupportActivity extends Activity implements LifecycleOwnerLifecycle
具有生命周期
Defines an object that has an Android Lifecycle. FragmentActivity classes implement LifecycleOwner interface which has the getLifecycle() method to access the Lifecycle. You can also implement LifecycleOwner in your own classes.
- Lifecycle 是一個抽象類，它持有關於組件(如 Activity 或 Fragment)生命周期狀態的信息，並且允許其他對象觀察此狀態。
- LifecycleOwner 持有 Lifecycle 對象，LifecycleOwner 通過 getLifecycle() 獲取內部 Lifecycle 對象，然后就可以注冊或取消注冊觀察者 LifecycleObserver。
- Lifecycle 使用兩個主要
枚舉來跟蹤其關聯組件的生命周期狀態State：當前生命周期所處狀態。由框架和 Lifecycle 類所調度的生命周期事件。這些事件映射到 Activity 或 Fragment 中的回調事件。Event：當前生命周期改變對應的事件。由 Lifecycle 對象所跟蹤[tracked]的組件的當前狀態。
將State視為圖形的節點[nodes]，將Event視為這些節點之間的邊緣[edges]。
LifecycleRegistry
Lifecycle 實現類
An implementation of Lifecycle that can handle multiple observers.
It is used by Fragments and Support Library Activities. You can also directly use it if you have a custom LifecycleOwner.
public class LifecycleRegistry extends Lifecycle繼承自 Lifecycle，是 Activity 或 Fragment 中所持有的 Lifecycle 對象的實際類型。
LifecycleRegistry 內部有一個成員變量 State 用於記錄當前的生命周期，當其生命周期改變后，LifecycleRegistry 就會逐個通知每一個注冊的 LifecycleObserver。
LifecycleRegistry 的內部類ObserverWithState：
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
}關系表：
使用案例
LifecycleObserver 的幾種實現方式
如果使用Java 8，建議使用DefaultLifecycleObserver觀察事件。要使用含它需添加 common-java8 依賴：
implementation 'android.arch.lifecycle:common-java8:1.1.1'如果使用Java 7，則可以使用注解觀察生命周期事件。
注意：一旦
Java 8語言成為Android的主流，針對Java 7提供的注解方式將會被棄用，因此在DefaultLifecycleObserver和注解之間，您應該始終優先選擇DefaultLifecycleObserver。
實際使用中，我們通常是將所有要觀察的生命周期事件都封裝到 BasePresenter 等實現類中，這樣每一個 BasePresenter 的子類都能感知到 Activity 對應的生命周期事件，並在子類重寫的方法中實現相應的行為。
LifecycleObserver 接口
實現類特點：
- 使用Observer注解的方法可以接收零個或一個參數。如果使用，則第一個參數必須是
LifecycleOwner類型。 - 使用
Lifecycle.Event.ON_ANY注解的方法可以接收第二個參數，該參數必須是Lifecycle.Event類型。 - 提供這些附加參數是為了方便您觀察多個providers和events而無需手動tracking它們。
public class BaseLifecycleObserver implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate() { //零個參數
Log.i("bqt", "Observer【onCreate】");
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
Log.i("bqt", "Observer【onStart】");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume(LifecycleOwner source) { //一個參數
Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void onPause() {
Log.i("bqt", "Observer【onPause】");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
Log.i("bqt", "Observer【onStop】");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy() {
Log.i("bqt", "Observer【onDestroy】");
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
public void onAny(LifecycleOwner source, Lifecycle.Event event) { //兩個參數
Log.i("bqt", "Observer【onAny】" + event.name());
}
}GenericLifecycleObserver 接口
public class BaseGenericLifecycleObserver implements GenericLifecycleObserver {
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
Log.i("bqt", "Observer【onCreate】");
break;
case ON_START:
Log.i("bqt", "Observer【onStart】");
break;
case ON_RESUME:
Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
break;
case ON_PAUSE:
Log.i("bqt", "Observer【onPause】");
break;
case ON_STOP:
Log.i("bqt", "Observer【onStop】");
break;
case ON_DESTROY:
Log.i("bqt", "Observer【onDestroy】");
break;
case ON_ANY:
Log.i("bqt", "Observer onAny");
break;
default:
Log.i("bqt", "Observer【不存在的事件】");
break;
}
}
}FullLifecycleObserver 接口
FullLifecycleObserver 接口繼承自 LifecycleObserver，並聲明了與 Activity 聲明周期一致的6個方法：
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);
}DefaultLifecycleObserver 接口
DefaultLifecycleObserver 接口繼承自 FullLifecycleObserver 接口，並利用 Java 8 的特性為每一個方法提供了空實現：
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
@Override
default void onCreate(@NonNull LifecycleOwner owner) {}
//...其他幾個方法類似
}這樣我們就不必重寫接口中的每一個方法了，只需重寫我們關心的方法即可。
public class MyDefaultLifecycleObserver implements DefaultLifecycleObserver {
@Override
public void onCreate(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onCreate】");
}
@Override
public void onStart(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onStart】");
}
@Override
public void onResume(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onResume】" + source.getLifecycle().getClass().getSimpleName());
}
@Override
public void onPause(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onPause】");
}
@Override
public void onStop(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onStop】");
}
@Override
public void onDestroy(@NonNull LifecycleOwner source) {
Log.i("bqt", "Observer【onDestroy】");
}
}在 Activity 中使用
public class LifecycleTestActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getLifecycle().addObserver(new BaseLifecycleObserver()); //在onCreate方法中注冊，以上三種使用任何一種效果都一樣
ImageView imageView = new ImageView(this);
imageView.setImageResource(R.drawable.icon);
setContentView(imageView);
}
}打印日志
Activity【onCreate】
Observer【onCreate】
Activity【onStart】
Observer【onStart】
Activity【onResume】
Observer【onResume】
------------------------------
Observer【onPause】
Activity【onPause】
Observer【onStop】
Activity【onStop】
Observer【onDestroy】
Activity【onDestroy】注意回調順序
- ON_CREATE, ON_START, ON_RESUME events in this class are dispatched after the LifecycleOwner's related method returns.
- ON_PAUSE, ON_STOP, ON_DESTROY events in this class are dispatched before the LifecycleOwner's related method is called.
- This gives you certain guarantees某些保證 on which state the owner is in.
這種結果的實現方式是通過：
- Activity 或 Fragment 中的 performCreate()、performStart()、performResume() 方法會先調用自身的 onXXX() 方法，然后再調用 LifecycleRegistry 的 handleLifecycleEvent() 方法；
- 而Activity 或 Fragment 中的 performPause()、performStop()、performDestroy() 方法則會先調用 LifecycleRegistry 的 handleLifecycleEvent() 方法 ，然后再調用自身的 onXXX() 方法。
在 Fragment 中使用
public class LifecycleTestFragment extends Fragment {
public LifecycleTestFragment() {
getLifecycle().addObserver(new BaseGenericLifecycleObserver()); //不是在onCreate等生命周期方法中注冊，而是在構造方法中就注冊
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
ImageView imageView = new ImageView(getContext());
imageView.setImageResource(R.drawable.icon);
return imageView;
}
}打印日志
Fragment【onAttach】
Fragment【onCreate】
Observer【onCreate】
Fragment【onViewCreated】
Fragment【onActivityCreated】
Fragment【onStart】
Observer【onStart】
Fragment【onResume】
Observer【onResume】
------------------------------
Observer【onPause】
Fragment【onPause】
Observer【onStop】
Fragment【onStop】
Fragment【onDestroyView】
Observer【onDestroy】
Fragment【onDestroy】
Fragment【onDetach】2018-10-2