Android lifecycle 使用详解

}

void create() {

//do something

}

void destroy() {

//do something

}

}

class MyActivity extends AppCompatActivity {

private MyPresenter presenter;

public void onCreate(…) {

presenter= new MyPresenter ();

presenter.create();

}

public void onDestroy() {

super.onDestroy();

presenter.destory();

}

}

当然我们也可以定义一些 IBasePresenter 的接口，在 BaseActivity 的时候调用 IBasePresenter 的 onDestroy 方法，这样也确实能做到。只不过稍微繁琐一点。

那如果是别的类的呢，比如 MediaCompoment，在 Activity 的时候，我们需要销毁一些资源，按照传统的方法，我们还是需要在 Activity onDestroy 的时候手动调用 onDestroy 方法。那有没有更好的方法呢?当然是有的，lifecycle 就可以解决这个问题。接下来，我们先来看一下 Lifycycle 的基本使用。

---

Lifycycle 的基本使用

---

1. 引入相关的依赖包

Lifecycle 已经是稳定版，它包含在 support library 26.1.0 及之后的依赖包中，如果我们的项目基于这些依赖包，那么不需要额外的引用。

// ViewModel and LiveData

implementation “android.arch.lifecycle:extensions:1.1.0”

// alternatively, just ViewModel

implementation “android.arch.lifecycle:viewmodel:1.1.0”

// alternatively, just LiveData

implementation “android.arch.lifecycle:livedata:1.1.0”

support library在26.1.0 之前，lifecycle 并没有集成进去，需要我们引入另外的包。

implementation “android.arch.lifecycle:extensions:1.0.0-alpha4”

2. 使用

这里同样分为几种情况

1. support library 26.1.0 之后，且继承 FragmentActivity，那么我们直接调用 getLifecycle().addObserver 方法即可，当 Activity 的生命周期变化的时候，将会回调 onStateChanged 的方法，状态分别是一一对应的

public class MainActivity extends AppCompatActivity {

private static final String TAG = “MainActivity”;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {

Log.d(TAG, “onStateChanged: event =” + event);

}

});

}

}

2. support library 26.1.0 之后，不是继承 FragmentActivity，只是简单地继承 Actiivty

public class SimpleLifecycleActivity extends Activity implements LifecycleOwner {

private static final String TAG = “SimpleLifecycleActivity”;

private LifecycleRegistry mLifecycleRegistry;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_simple_lifecycle);

mLifecycleRegistry = new LifecycleRegistry(this);

mLifecycleRegistry.markState(Lifecycle.State.CREATED);

getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {

Log.d(TAG, “onStateChanged: event =” + event);

}

});

}

@Override

protected void onStart() {

super.onStart();

mLifecycleRegistry.markState(Lifecycle.State.STARTED);

}

@NonNull

@Override

public Lifecycle getLifecycle() {

return mLifecycleRegistry;

}

}

3. support library 26.1.0 之前

（现在的 support library 基本都在 26.1.0 之后了，这个可以忽略）

第一步：实现 LifecycleOwner 接口，并返回响应的 Lifecycle

public interface LifecycleOwner {

/**

• Returns the Lifecycle of the provider.

• @return The lifecycle of the provider.

*/

@NonNull

Lifecycle getLifecycle();

}

第二步：在 Activity 生命周期变化的时候，调用 mLifecycleRegistry.handleLifecycleEvent 方法，分发相应的生命周期。

第三步：调用 Lifecycle 的 addObserver 方法添加相应的 Observer。

代码如下

public class MainActivity extends AppCompatActivity implements LifecycleOwner {

private LifecycleRegistry mRegistry;

private static final String TAG = “MainActivity”;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mRegistry = new LifecycleRegistry(this);

mRegistry.markState(Lifecycle.State.CREATED);

getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override

public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {

Log.d(TAG, “onStateChanged:event =” + event);

}

@Override

public Object getReceiver() {

return null;

}

});

}

@Override

protected void onStart() {

super.onStart();

mRegistry.markState(Lifecycle.State.STARTED);

mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);

}

@Override

protected void onResume() {

super.onResume();

mRegistry.markState(Lifecycle.State.RESUMED);

mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);

}

@Override

protected void onPause() {

super.onPause();

mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);

}

@Override

protected void onStop() {

super.onStop();

mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);

}

@Override

protected void onDestroy() {

super.onDestroy();

mRegistry.markState(Lifecycle.State.DESTROYED);

mRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);

}

@Override

public Lifecycle getLifecycle() {

return mRegistry;

}

}

---

总结

---

我们回过头来看一下我们上面提出的问题？

MediaCompoment 在 Activity ondestroy 的时候，我们需要销毁一些资源，用传统的方法，我们需要在 Activity onDestroy 的时候手动调用 onDestroy 方法。这样会存在一个问题，调用者必须知道比较清楚得知道 MediaCompoment 的设计，否则可能会忘记调用 onDestroy 的方法。

那有没有一种方法， 当 Activity 生命周期变化的时候，MediaCompoment 自身能够检测到 Activity 的 生命周期变化，从而做相应的处理。

答案当然是有的，使用 lifycycle。

public class MediaCompoment {

private static final String TAG = “MediaCompoment”;

private final LifecycleOwner mLifecycleOwner;

public MediaCompoment(LifecycleOwner lifecycleOwner) {

mLifecycleOwner = lifecycleOwner;

mLifecycleOwner.getLifecycle().addObserver(new GenericLifecycleObserver() {

@Override

public void onStateChanged(LifecycleOwner source, final Lifecycle.Event event) {

if (event == Lifecycle.Event.ON_CREATE) {

onCreate();