Jetpack里面的内容还是相当丰富了,有兴趣的可以去官网了解一番。
这里讲到的是 Lifecycle,中文意思就是生命周期。如果说你想让某一个类能够观察
Activity 或 Fragment 的生命周期,那 Lifecycle 可以很轻松的帮你实现。有用过 MVP模式的话,你应该经常需要 Presenter 感知 View(Activity/Frament 统称 View) 的生命周期,以便处理业务逻辑。当你没接触 Lifecycle 的时候,获取会通过接口的方式通知 Presenter,例如以下代码:
1.定义一个接口:
public interface ILifecycleView {
void onCreate();
void onStart();
void onPause();
void onResume();
void onDestroy();
}
2.Presenter 代码块:
public class MainPresenter implements ILifecycleView {
private static final String TAG = "MainPresenter";
@Override
public void onCreate() {
Log.d(TAG, "onCreate");
}
@Override
public void onStart() {
Log.d(TAG, "onStart");
}
@Override
public void onPause() {
Log.d(TAG, "onPause");
}
@Override
public void onResume() {
Log.d(TAG, "onResume");
}
@Override
public void onDestroy() {
Log.d(TAG, "onDestroy");
}
}
3.View 代码块:
public class MainActivity extends AppCompatActivity {
private MainPresenter mainPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mainPresenter = new MainPresenter();
mainPresenter.onCreate();
}
@Override
protected void onStart() {
super.onStart();
mainPresenter.onStart();
}
@Override
protected void onPause() {
super.onPause();
mainPresenter.onPause();
}
@Override
protected void onResume() {
super.onResume();
mainPresenter.onResume();
}
@Override
protected void onDestroy() {
super.onDestroy();
mainPresenter.onDestroy();
}
}
这样 Presenter 也能轻监听到View的生命周期,其实这并不是那么轻松,当 Presenter 有很多的时候你就会有感觉了,所以 Lifecycle 就能派上用场了。还是看代码
1.Lifrcycle简单应用
public class MainPresenter implements DefaultLifecycleObserver {
private final static String TAG = "MainPresenter";
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onCreate");
}
@Override
public void onStart(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onStart");
}
@Override
public void onPause(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onPause");
}
@Override
public void onResume(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onResume");
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onStop");
}
@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
Log.d(TAG, "onDestroy");
}
}
public class MainActivity extends AppCompatActivity {
private MainPresenter mainPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mainPresenter = new MainPresenter();
getLifecycle().addObserver(mainPresenter);
}
@Override
protected void onDestroy() {
super.onDestroy();
getLifecycle().removeObserver(mainPresenter);
}
}
运行结果GIF:
让 Presenter 具有感知生命周期的能力变得更加简单了,只需要两步:
1.Presenter 实现 DefaultLifecycleObserver(DefaultLifecycleObserver 是 LifecycleObserver 的一个实现接口,稍后会讲解到)
2.在 Activity 中调用 getLifecycle().addObserver(mainPresenter) 将 mainPresenter 传到 Lifecycle 中。
总体来说比前面的方式简单不少,说了这么多,操作起来是方便,但是不懂的人会就会有疑惑,为啥这么写就能让 Presenter 感知View的生命周期呢?看看源码就能解开当中的疑惑了。
2.Lifecycle 源码分析
Lifecycle 内部实现原理就是观察者模式,上面的例子 MainPresenter 就是一个观察者,Lifecycle 或者说 View 是被观察者。所以你会看到 MainPresenter 实现了 DefaultLifecycleObserver,该类是 LifecycleObserver 的实现类。
/**
* Callback interface for listening to {@link LifecycleOwner} state changes.
* <p>
* If you use Java 8 language, <b>always</b> prefer it over annotations.
*/
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
/**
* Notifies that {@code ON_CREATE} event occurred.
* <p>
* This method will be called after the {@link LifecycleOwner}'s {@code onCreate}
* method returns.
*
* @param owner the component, whose state was changed
*/
@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
/**
* Notifies that {@code ON_START} event occurred.
* <p>
* This method will be called after the {@link LifecycleOwner}'s {@code onStart} method returns.
*
* @param owner the component, whose state was changed
*/
@Override
default void onStart(@NonNull LifecycleOwner owner) {
}
//省略部分源码
}
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);
}
/**
* Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
* {@link OnLifecycleEvent} annotated methods.
* <p>
* @see Lifecycle Lifecycle - for samples and usage patterns.
*/
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {
}
从源码可以看出 DefaultLifecycleObserver 只是一个很简单的接口类,每个方法的参数都是 LifecycleOwner ,而这个 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.
*
* @see Lifecycle
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
接着看 MainActivity 的 getLifecycle().addObserver(mainPresenter) 这行代码,
getLifecycle() 提供一个 LifecycleRegistry ,具体源码就不贴出来了,这个比较简单。看看 LifecycleRegistry 源码:
/**
* An implementation of {@link Lifecycle} that can handle multiple observers.
* <p>
* 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 {
LifecycleRegistry 是 Lifecycle 的实现类,在看看 Lifecycle 源码:
public abstract class Lifecycle {
Lifecycle 是一个抽象类,包含 了两个主要的抽象方法方法
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
这两个就是前面用到的两个方法,添加观察者与移除观察者(防止内存泄漏)。
看看 LifecycleRegistry 对 addObserver() 的实现逻辑
162行可以看到通过 LifecycleObserver 和 State 生成了一个 ObserverWithState, LifecycleObserver 就是我们的MainPresenter,而 State 是 Lifecycle 里面的枚举
State 代表当前 View 的生命周期状态, ObserverWithState 是 LifecycleRegistry 的一个静态内部类
从源码可以看出 View 的生命周期就是通过这个内部类的 dispatchEvent(LifecycleOwner owner, Event event) 方法来通知观察者。整个回调流程如下截图:
然后到了 ReportFragment 这里
每个生命周期的函数都会调用 dispatch()方法。
最后终于到了 SupportActivity 了,看截图
是在这里将 SupportActivity 注入到了 ReportFragment 里。整个通知回调就是这样子了。稍微细心一点你会发现 LifecycleRegistry 是在 SupportActivity 的28行创建的,也就是说如果我们的 MainActivity 是继承 Activity 而不是它的子类的话,是找不到getLifecycle() 这个方法的。