Jetpack:Lifecycle
1.问题引入
通常我们都会用MVP模式把业务逻辑和数据处理分开，但是这样做有个小问题：如果在某个生命周期还有别的类要监听 Activity 生命周期变化，那也需要添加许多生命周期的回调方法，比较繁琐。那我们是否可以当 Activity 生命周期发生变化的时候主动通知呢？答案就是使用 Lifecycle 提供的 LifecycleObserver
2.Lifecycle使用
（1）和MVP一样，要有一个最基础的接口
public interface BasePresenter {
void onCreate();
void onStart();
void onResume();
void onPause();
void onStop();
void onDestroy();
}（2）实例化presenter并且还要实现Lifecycle接口
/**
* 如果是java8的话就用DefaultLifecycleObserver
*/
public class MainActivityObserver implements BasePresenter, LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
@Override
public void onCreate() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
@Override
public void onStart() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
@Override
public void onResume() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
@Override
public void onPause() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
@Override
public void onStop() {
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
@Override
public void onDestroy() {
}
}（3）在Activity里面使用
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new MainActivityObserver());
}
}3.源码解析
1.getLifecycle的实现
最终是在SupportActivity里面实现的
public class SupportActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
//横竖屏切换的时候
mLifecycleRegistry.markState(Lifecycle.State.CREATED);
super.onSaveInstanceState(outState);
}
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}为什么只在SupportActivity里面实现呢？如果我一开始继承的是Activity呢？其实，Google工作人员表示开发Lifecycle并没有针对android.app.* Activity和Fragment，近期也未打算支持android.app.*。具体参见官方解释。这里推荐大家更多的使用support包，不同版本platform中Activity和Fragment还存在大量support包中已修复的bug。 所以为了安全性以及版本的兼容，仿照这个推荐自己实现LifecycleRegistry
注意看ReportFragment。很明显就是用来处理生命周期的
public class ReportFragment extends Fragment {
private ActivityInitializationListener mProcessListener;
private void dispatchCreate(ActivityInitializationListener listener) {
if (listener != null) {
listener.onCreate();
}
}
private void dispatchStart(ActivityInitializationListener listener) {
if (listener != null) {
listener.onStart();
}
}
private void dispatchResume(ActivityInitializationListener listener) {
if (listener != null) {
listener.onResume();
}
}
@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);
mProcessListener = null;
}
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
......
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
void setProcessListener(ActivityInitializationListener processListener) {
mProcessListener = processListener;
}
interface ActivityInitializationListener {
void onCreate();
void onStart();
void onResume();
}
}很明显，调用了生命周期函数，同时也调用了自身的处理生命周期的函数 接下来看handleLifecycleEvent
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
最终会调用ObserverWithState.dispatchEvent2.addObserver分析
@Override
public void addObserver(LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
statefulObserver.dispatchEvent(mLifecycleOwner, upEvent(statefulObserver.mState));
//也就是ObserverWithState.dispatchEvent
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}看一下ObserverWithState
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);
//也就是GenericLifecycleObserver的onStateChanged，但是没有实现
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}3.总结
Lifecycle内部的实现机制就是用ReportFragment来响应生命周期的（和Glide有点类似）。当然，光一个Lifecycle看不出什么，如果和LiveData和ViewModel一起用就会很好
本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录