一唤反、使用Lifecycle
1. 引入Lifecycle
我們來看一下如何引入:
1.非androidX項目引入:
//運行時
implementation "android.arch.lifecycle:runtime:1.1.1"
// 編譯期
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"
2.androidX項目引入:
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
2. 創(chuàng)建生命周期觀察者
我們首先創(chuàng)建了一個類,它實現(xiàn)了LifecycleObserver接口,并且我寫了幾個模擬生命周期的方法,并在每個方法上加上了日志.
public class MyObserver implements LifecycleObserver {
private static final String TAG = "MyObserver";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate() {
Log.w(TAG, "onCreate: ");
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
Log.w(TAG, "onStart: ");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume() {
Log.w(TAG, "onResume: ");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void onPause() {
Log.w(TAG, "onPause: ");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
Log.w(TAG, "onStop: ");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void onDestroy() {
Log.w(TAG, "onDestroy: ");
}
}
3. 注冊觀察Activity生命周期
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//添加一個生命周期觀察者 getLifecycle()是FragmentActivity中的方法
MyObserver observer = new MyObserver();
getLifecycle().addObserver(observer);
}
}
觀察運行打印日志
2019-03-12 22:14:26.672 15790-15790/? W/MyObserver: onCreate:
2019-03-12 22:14:26.676 15790-15790/? W/MyObserver: onStart:
2019-03-12 22:14:26.679 15790-15790/? W/MyObserver: onResume:
2019-03-12 22:15:13.054 15790-15790/? W/MyObserver: onPause:
2019-03-12 22:15:13.234 15790-15790/? W/MyObserver: onStop:
2019-03-12 22:15:13.241 15790-15790/? W/MyObserver: onDestroy:
為此我們可以用這個來觀察acitvity生命周期谱仪，并及時處理回收處理等操作，保證內(nèi)存泄漏等問題匈子。
二、Lifecycle原理解析
1.activity是如何分發(fā)生命周期的撞反？
我們從使用入手似扔，點擊getLifecycle()
MyObserver observer = new MyObserver();
getLifecycle().addObserver(observer);
我們看到mLifecycleRegistry是ComponentActivity的一個成員變量,用來管理向其注冊生命周期觀察者
public class ComponentActivity extends Activity
implements LifecycleOwner, KeyEventDispatcher.Component {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
LifecycleRegistry是Lifecycle的一個實現(xiàn),而Lifecycle是一個抽象類,里面有3個方法(添加觀察者和移除觀察者,獲取當前的狀態(tài))
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
@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,
/**
* Constant for onResume event of the {@link LifecycleOwner}.
*/
ON_RESUME,
/**
* Constant for onPause event of the {@link LifecycleOwner}.
*/
ON_PAUSE,
/**
* Constant for onStop event of the {@link LifecycleOwner}.
*/
ON_STOP,
/**
* Constant for onDestroy event of the {@link LifecycleOwner}.
*/
ON_DESTROY,
/**
* An {@link Event Event} constant that can be used to match all events.
*/
ON_ANY
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
2.竟然有了觀察管理者LifecycleRegistry，它又是如何分發(fā)生命周期的呢垄惧？
點擊進入ComponentActivity的onCreate()方法刁愿，里面有ReportFragment，看名字是不是很熟悉赘艳，難道這個就是用來上報Activity生命周期的酌毡？
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
沒錯,其實ReportFragment就是在Activity中添加一個空白Fragment,有Fragment的生命周期,當然我們就知道了Activity的生命周期,接著通知相關的觀察者即可.
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
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();
}
}
其實這個injectIfNeededIn()看起來像是注入的方法干的就是將Fragment添加到Activity中,
來看看這個ReportFragment的生命周期方法都干了些啥,
@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);
}
private void dispatchCreate(ActivityInitializationListener listener) {
if (listener != null) {
listener.onCreate();
}
}
通過調(diào)用dispatchCreate(mProcessListener)方法,感覺從命名上看分發(fā)當前的生命周期事件.
dispatch(Lifecycle.Event.ON_START); 也像是在分發(fā)事件.
我們跟著這個mProcessListener來看看是在哪里設置的
/**
* Class that provides lifecycle for the whole application process.
*/
public class ProcessLifecycleOwner implements LifecycleOwner {
//注意,我是一個單例
private static final ProcessLifecycleOwner sInstance = new ProcessLifecycleOwner();
static void init(Context context) {
sInstance.attach(context);
}
void attach(Context context) {
mHandler = new Handler();
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
Application app = (Application) context.getApplicationContext();
app.registerActivityLifecycleCallbacks(new EmptyActivityLifecycleCallbacks() {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
ReportFragment.get(activity).setProcessListener(mInitializationListener);
}
@Override
public void onActivityPaused(Activity activity) {
activityPaused();
}
@Override
public void onActivityStopped(Activity activity) {
activityStopped();
}
});
}
}
//Activity的監(jiān)聽器
ActivityInitializationListener mInitializationListener =
new ActivityInitializationListener() {
@Override
public void onCreate() {
}
@Override
public void onStart() {
activityStarted();
}
@Override
public void onResume() {
activityResumed();
}
private final LifecycleRegistry mRegistry = new LifecycleRegistry(this);
//Activity創(chuàng)建的時候,分發(fā)Lifecycle.Event.ON_START事件
void activityStarted() {
mStartedCounter++;
if (mStartedCounter == 1 && mStopSent) {
mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
mStopSent = false;
}
}
ReportFragment.java
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
ProcessLifecycleOwner的attach()中registerActivityLifecycleCallbacks()注冊了一個監(jiān)聽器,一旦有Activity創(chuàng)建就給它設置一個Listener.這樣就保證了每個ReportFragment都有Listener.
既然是一個全局的單例,并且可以監(jiān)聽整個應用程序的生命周期,那么,肯定一開始就需要初始化. 既然沒有讓我們在Application里面初始化,那么肯定就是在ContentProvider里面初始化的.
3. ProcessLifecycleOwner 在ContentProvider初始化
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
@Override
public boolean onCreate() {
LifecycleDispatcher.init(getContext());
ProcessLifecycleOwner.init(getContext());
return true;
}
}
1.ProcessLifecycleOwner初始化就不說了,是拿來觀察整個應用的生命周期的,其原理就是利用ReportFragment,我們稍后詳細到來.
2.LifecycleDispatcher尤其重要.
class LifecycleDispatcher {
static void init(Context context) {
...
//registerActivityLifecycleCallbacks 注冊一個監(jiān)聽器
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}
}
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
//又來注入咯
ReportFragment.injectIfNeededIn(activity);
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
}
初始化的時候,就注冊了一個監(jiān)聽器,每個創(chuàng)建的時候都給它注入一個ReportFragment.
那為什么在Activity onCreate還要再注入一個ReportFragment,可能2次注入,確保萬無一失，但不管注冊幾次蕾管，內(nèi)部實現(xiàn)是只會成功注入一次的,所以多調(diào)用一次,無所謂
4.事件分發(fā)
前面講的有點啰嗦枷踏，接下來我們來看下是如何一步一步分發(fā)生命周期事件的
ReportFragment.java
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {
//獲取Activity中的LifecycleRegistry
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
......
sync();
......
}
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
//循環(huán) 遍歷所有觀察者
while (...) {
....
//分發(fā)事件
forwardPass(lifecycleOwner);
}
}
注意看分發(fā)生命周期會根據(jù)狀態(tài)，小于當前狀態(tài)的都會一并分發(fā)
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();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
//分發(fā)事件
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
