淺談Android的Lifecycle源碼分析
1. 簡介
很早就聽說了Google的Lifecycle組件，因為項目沒有使用過，所以并沒有過多的接觸。不過最近看到了一篇文章，其中的一條評論提到了LiveData。恰巧這兩天工作內容不多，所以趕緊研究一波！
不過在看LiveData之前，我覺得還是先看下Lifecycle吧（Lifecycle更像是LiveData的基礎）。
2. Lifecycle的簡單介紹
Lifecycle的介紹，我們還是拿Google的官方文檔作為參考吧。
Lifecycle主要解決的是業(yè)務和Activity/Fragment生命周期相關的問題。例如：我們在onResume()/onStart()中請求定位，在onPause()/onStop()中停止定位。那么我們一般的做法：
class MyLocationListener {
public MyLocationListener(Context context, Callback callback) {
// ...
}
void start() {
// connect to system location service
}
void stop() {
// disconnect from system location service
}
}
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
@Override
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, (location) -> {
// update UI
});
}
@Override
public void onStart() {
super.onStart();
myLocationListener.start();
// manage other components that need to respond
// to the activity lifecycle
}
@Override
public void onStop() {
super.onStop();
myLocationListener.stop();
// manage other components that need to respond
// to the activity lifecycle
}
}
上面的代碼雖然看起來還可以，但在真實的應用程序中，可能會有很多的方法都需要根據當前Activity/Fragment的生命周期來進行不同的操作。因此其生命周期方法中可能會被放置大量代碼，例如onStart()和 onStop()中，這使得它們難以維護。因此Lifecycle應運而生！
3. Lifecycle的使用
Lifecycle已經發(fā)布了release版，所以其中的一些默認支持已經包含到了support-v7:26.1.0以及更高。
添加依賴：
implementation "android.arch.lifecycle:extensions:1.1.1" annotationProcessor "android.arch.lifecycle:compiler:1.1.1"
使用方式1：實現LifecycleObserver接口，使用@OnLifecycleEvent注解，通過編譯時注解生成代碼：
public class MyLifecycleObserver implements LifecycleObserver {
private static final String TAG = MyLifecycleObserver.class.getSimpleName();
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void start(LifecycleOwner lifecycleOwner) {
Lifecycle.State currentState = lifecycleOwner.getLifecycle().getCurrentState();
Log.d(TAG, "start: " + currentState);
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void stop(LifecycleOwner lifecycleOwner) {
Log.d(TAG, "stop: " + lifecycleOwner.getLifecycle().getCurrentState());
}
}
APT生成的代碼
使用方式2：實現GenericLifecycleObserver接口，實現其onStateChanged方法：
public class MyLifecycleObserver implements GenericLifecycleObserver {
private static final String TAG = MyLifecycleObserver.class.getSimpleName();
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
Log.d(TAG, event.name());
}
}
創(chuàng)建完成后，我們需要將其添加：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new MyLifecycleObserver());
}
}
結果圖：
方法1
方法2
4. 源碼分析
1.Lifecycle的獲取
根據源碼追蹤我們可以看到Lifecycle是在SupportActivity中：
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
這里還有個挺重要的代碼：
SupportActivity.java
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
ReportFragment.java
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();
}
}
這里在Activity中添加了一個Fragment，至于作用，留到后面在講。
2.addObserver
addObserver方法的話，還是簡單來看吧：
LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
......
// 對狀態(tài)的修正，這里會對已經過去的狀態(tài)進行分發(fā)。也就是說如果添加observer時狀態(tài)已經改變，那么也會被通知到！
}
// 有狀態(tài)的Observer
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
我們將實現的接口通過裝飾者（我認為是這樣）模式轉成ObserverWithState對象，并將該對象添加到mObserverMap中。
在ObserverWithState的構造方法中，有對我們傳入的LifecycleObserver進行包裝：
Lifecycling.java
@NonNull
static GenericLifecycleObserver getCallback(Object object) {
// 這里應該算第三種實現方式，然而FullLifecycleObserver不是public，所以不能使用
if (object instanceof FullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
}
// 我們的第一種方式
if (object instanceof GenericLifecycleObserver) {
return (GenericLifecycleObserver) object;
}
// 通過注解生成的
final Class<?> klass = object.getClass();
// 將生成的MyLifecycleObserver_LifecycleAdapter放到Map中
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);
}
根據我們傳入的對象進行解析，最終返回結果為：GenericLifecycleObserver或者GenericLifecycleObserver的實現類。附獲取生成MyLifecycleObserver_LifecycleAdapter代碼：
// 通過名稱獲取
public static String getAdapterName(String className) {
return className.replace(".", "_") + "_LifecycleAdapter";
}
最終通過Class.forName方式獲得Class。
3.事件分發(fā)
Lifecycle的事件分發(fā)在ObserverWithState類中：
// 事件分發(fā)
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
看下哪里調用了dispatchEvent方法：
調用
我們看這個方法，其中一個在addObserver中調用，另外的兩個都會通過sync()方法調用：
// happens only on the top of stack (never in reentrance),
// so it doesn't have to take in account parents
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
+ "new events from it.");
return;
}
// 最新的狀態(tài)和當前狀態(tài)不一致，則需要進行狀態(tài)修改
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);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
mNewEventOccurred = false;
}
// 是否狀態(tài)同步的
private boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
// 最新的和最后添加的Observer狀態(tài)一致，并且當前的狀態(tài)和最新狀態(tài)一致，則已經同步了
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
這里的同步方法用于同步當前Observer的狀態(tài)，如果最新的和最老的Observer的狀態(tài)不一致或者當前的狀態(tài)和最新的狀態(tài)不一致時，那么需要進行狀態(tài)同步。同步包括了向前同步和向后同步。
調用sync()方法一共就兩處，一處在addObserver方法，另一處是moveToState方法，而調用moveToState方法也有兩處：
@SuppressWarnings("WeakerAccess")
@MainThread
public void markState(@NonNull State state) {
moveToState(state);
}
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
handleLifecycleEvent方法有很多處調用：
handleLifecycleEvent調用
看圖的話，就可以知道Fragment在不同的生命周期調用了handleLifecycleEvent方法，隨便看一個吧：
ON_CREATE
還記得上面說的ReportFragment嗎？這里也出現了，我們看下ReportFragment到底做什么的：
// 調用Activity的
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 onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
// just want to be sure that we won't leak reference to an activity
mProcessListener = null;
}
可以看到，ReportFragment只是作為一個中間層，通過它來分發(fā)各種事件！
由于篇幅原因（已經啰嗦了很多了），這里就不寫LifecycleDispatcher和ProcessLifecycleOwner了，這兩個通過自定義的內容提供者ProcessLifecycleOwnerInitializer進行初始化，并且通過registerActivityLifecycleCallbacks和registerFragmentLifecycleCallbacks注冊統一的觀察回調。有興趣的話，自己看看吧。
5 總結
Lifecycle簡單來說就是用于處理和生命周期相關的業(yè)務，其原理以及實現還是很簡單的。當然了，項目中并沒有使用到Lifecycle，所以實際應用效果怎樣只能靠猜想了😂。后面呢，應該會分析下與Lifecycle相關的一個東西LievData，要抓緊時間了！
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。
相關文章
這篇文章主要介紹了詳解Android框架MVVM分析以及使用，對MVVM感興趣的同學，一定要看一下2021-04-04
這篇文章主要為大家介紹了Android Intent傳遞大量數據出現問題解決，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-07-07
這篇文章主要為大家詳細介紹了Android webview打開本地圖片上傳的實現代碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-02-02
這篇文章主要為大家詳細介紹了Android多線程下載示例，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-11-11
這篇文章主要介紹了Andriod使用多線程實現輪播圖片效果，非常不錯，具有參考借鑒價值,需要的朋友可以參考下2017-10-10
Android socket實現原理詳解 服務端和客戶端如何搭建
這篇文章主要為大家詳細介紹了Android socket實現原理詳解，以及服務端和客戶端的搭建方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-08-08
Android 中使用ContentObserver模式獲取短信用正則自動填充驗證碼
這篇文章主要介紹了Android 中使用ContentObserver模式獲取短信用正則自動填充驗證碼，首先使用了ContentObserver監(jiān)聽短信,然后從短信中用正則的分組去拿到驗證碼，具體實現代碼大家參考下本文2017-02-02
Android中的Adapter簡單介紹，需要的朋友可以參考一下2013-06-06
下面小編就為大家?guī)硪黄昝澜鉀Q安卓jni項目會刪除其他so文件的問題。小編覺得挺不錯的，現在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2016-12-12
Android貝塞爾曲線初步學習第三課 Android實現添加至購物車的運動軌跡
這篇文章主要為大家詳細介紹了Android貝塞爾曲線初步學習第三課，Android實現添加至購物車的運動軌跡，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-03-03