为了账号安全,请及时绑定邮箱和手机立即绑定

Android lifecycle 使用详解

标签:
Android

简介

Architecture Components  

lifecycle 是 2107 年 google 大会推出来的,它属于 architecture compoment 里面的一个组件,它可以干什么用呢? 简单得来说,它可以用来检查 Activity 的生命周期,而不必强依赖  Activity。


为什么要引进 lifecycle

举一下我们最常用的 MVP 例子,没引进 lifecycle 之前,我们需要在 Activity 或者 Fragment 销毁的时候,即 onDestroy 的时候手动调用 onDestroy 方法,这里会带来一些问题,每一次在 Activity 或者 Fragment 销毁的烧开后都要调用 presenter.destory() 方法,这样的代码枯燥,毫无意义。

class MyPresenter{    public MyPresenter() {
    }    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 LiveDataimplementation "android.arch.lifecycle:extensions:1.1.0"// alternatively, just ViewModelimplementation "android.arch.lifecycle:viewmodel:1.1.0"// alternatively, just LiveDataimplementation "android.arch.lifecycle:livedata:1.1.0"

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

implementation "android.arch.lifecycle:extensions:1.0.0-alpha4"
  1. 使用

这里同样分为几种情况

  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);
            }
        });
    }
    
}
  1. 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;
    }

}
  1. 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();
                } else if (event == Lifecycle.Event.ON_START) {
                    onStart();
                } else if (event == Lifecycle.Event.ON_RESUME) {
                    onResume();
                } else if (event == Lifecycle.Event.ON_PAUSE) {
                    onPause();
                } else if (event == Lifecycle.Event.ON_STOP) {
                    onStop();
                } else if (event == Lifecycle.Event.ON_DESTROY) {
                    onDestroy();
                }
            }
        });
    }

    public void onCreate() {
        Log.d(TAG, "onCreate:");
    }

    public void onStart() {
        Log.d(TAG, "onStart:");
    }

    public void onResume() {
        Log.d(TAG, "onResume:");
    }

    public void onPause() {
        Log.d(TAG, "onPause:");
    }

    public void onStop() {
        Log.d(TAG, "onStop:");
    }

    public void onDestroy() {
        Log.d(TAG, "onDestroy:");
    }
}



作者:xujun9411
链接:https://www.jianshu.com/p/722a9e899c95


点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消