添加依赖
首先在工程根目录的build.gradle中添加一下内容：
buildscript {
...
ext.lifecycle_version = '1.1.1'
ext.room_version = '1.1.1'
...
}
allprojects {
repositories {
jcenter()
maven { url 'https://maven.google.com' } //添加此行
}
}
然后在应用目录下的build.gradle中添加以下依赖：
//For Lifecycles, LiveData, and ViewModel
implementation "android.arch.lifecycle:runtime:&lifecycle_version"
compile "android.arch.lifecycle:extensions:&lifecycle_version"
annotationProcessor "android.arch.lifecycle:compiler:&lifecycle_version"
//alternately - if using Java8, use the following instead of compiler
implementation "android.arch.lifecycle:common-java8:&lifecycle_version"
//For Room
compile "android.arch.persistence.room:runtime:1.0.0-alpha1"
annotationProcessor "android.arch.persistence.room:compiler:1.0.0-alpha1"
- LifeCyle类持有Activity或者Fragment的生命周期相关信息，并且支持其他对象监听这些状态。
- LifeCyle有两个枚举用于追踪生命周期中的状态。
Event
这是生命周期的事件类，会在Framework和LifeCycle间传递，这些事件映射到Activity和Fragment的回调事件中。
State
LifeCycle所持有Activity或Fragment的当前状态。
如图：
生命周期
LifeCycle相关使用
从官网介绍的例子看，在没引进Lifecycle时，在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：
在Activity的onCreate()中初始化某些成员（比如MVP架构中的Presenter，或者AudioManager、MediaPlayer、LocationListener等），然后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样导致我们的代码也许会像这样：
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;
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, location -> {
// update UI
});
}
@Override
public void onStart() {
super.onStart();
Util.checkUserStatus(result -> {
// what if this callback is invoked AFTER activity is stopped?
if (result) {
myLocationListener.start();
}
});
}
@Override
public void onStop() {
super.onStop();
myLocationListener.stop();
}
}
虽然以上代码看起来很简洁，但在实际项目中的onStart，onStop方法可能会变得相当庞大。
一个类想要监听LifeCycle的状态，只需要给其方法加上注解：
/**
* java 8.0之前 minsdkversion24之前可用，需要注释实现生命周期观察
*/
interface IPresenterOld : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
fun onCreate(owner: LifecycleOwner)
@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun onStart(owner: LifecycleOwner)
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onResume(owner: LifecycleOwner)
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun onPause(owner: LifecycleOwner)
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy(owner: LifecycleOwner)
}
可以直接实现 DefaultLifecycleObserver 接口，必须用" implementation "android.arch.lifecycle:common-java8:1.1.1" "，另外 minsdkversion 要大于24
interface IPresenter: DefaultLifecycleObserver {}
我们查看下DefaultLifecycleObserver源码：
package android.arch.lifecycle;
import android.support.annotation.NonNull;
@SuppressWarnings("unused")
public interface DefaultLifecycleObserver extends FullLifecycleObserver {
@Override
default void onCreate(@NonNull LifecycleOwner owner) {
}
@Override
default void onStart(@NonNull LifecycleOwner owner) {
}
@Override
default void onResume(@NonNull LifecycleOwner owner) {
}
@Override
default void onPause(@NonNull LifecycleOwner owner) {
}
@Override
default void onStop(@NonNull LifecycleOwner owner) {
}
@Override
default void onDestroy(@NonNull LifecycleOwner owner) {
}
}
FullLifecycleObserver:
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);
}
从下图我们可以更清晰的了解Lifecycle与activity/fragment生命周期的关系
Lifecycle时序图
LifeCycleOwner是一个只有一个方法的接口用于表明其有一个LifeCycle对象。这个方法为getLifecycle()。
这个对象给Acitivity，Fragment和LifeCycle提供了一个很好的抽象关系，Activity和Fragment只要实现这个接口就能配合LifeCycle实现生命周期监听。
class LifeCyclesActivity : AppCompatActivity() {
val TAG = "LifeCyclesActivity"
lateinit var mPresenter: IPresenter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val binding: ActivityLifeCyclesBinding = DataBindingUtil.setContentView(this, R.layout.activity_life_cycles)
mPresenter = MainPresenter(this)
lifecycle.addObserver(mPresenter)
}
override fun onStart() {
super.onStart()
Log.d(TAG, "onStart: ")
}
override fun onResume() {
super.onResume()
Log.d(TAG, "onResume: ")
}
override fun onPause() {
super.onPause()
Log.d(TAG, "onPause: ")
}
override fun onStop() {
super.onStop()
Log.d(TAG, "onStop: ")
}
override fun onDestroy() {
super.onDestroy()
Log.d(TAG, "onDestroy: ")
}
}
MainPresenter:
class MainPresenter : IPresenter {
val TAG = "MainPresenter"
constructor(context: Context)
override fun onCreate(owner: LifecycleOwner) {
Log.d(TAG, "onCreate: ")
}
override fun onStart(owner: LifecycleOwner) {
Log.d(TAG, "onStart: ")
}
override fun onResume(owner: LifecycleOwner) {
Log.d(TAG, "onResume: ")
}
override fun onPause(owner: LifecycleOwner) {
Log.d(TAG, "onPause: ")
}
override fun onDestroy(owner: LifecycleOwner) {
Log.d(TAG, "onDestroy: ")
}
}
根据Log，我们可以清楚的看到MainPresenter的方法同activity的生命周期
还可以对自定义的View添加生命周期的处理
binding.testTextview.lifecycle = lifecycle
lifecycle.addObserver(binding.testTextview)
TestTextView，也继承了IPresenter
class TestTextView : AppCompatTextView, IPresenter {
var lifecycle: Lifecycle? = null
var enable: Boolean = true
lateinit var buffer: StringBuffer
constructor(context: Context, attributeSet: AttributeSet) : super(context, attributeSet) {
buffer = StringBuffer()
}
fun setLifecycleEnable(enable: Boolean) {
this.enable = enable
lifecycle?.apply {
if(currentState.isAtLeast(Lifecycle.State.STARTED)){
}
}
}
override fun onCreate(owner: LifecycleOwner) {
if (enable) {
buffer.append(System.currentTimeMillis().toString() + "-onCreate\n")
this.text = buffer
}
}
override fun onResume(owner: LifecycleOwner) {
if (enable) {
buffer.append(System.currentTimeMillis().toString() + "-onResume\n")
this.text = buffer
}
}
override fun onPause(owner: LifecycleOwner) {
if (enable) {
buffer.append(System.currentTimeMillis().toString() + "-onPause\n")
this.text = buffer
}
}
}
···
参考：
网友评论