Android lifecycle 使用详解

时间 2020-08-04

原文原文链接

本文连接：https://blog.csdn.net/gdutxiaoxu/article/details/86660746android

说在前面

本次推出 Android Architecture Components 系列文章，目前写好了四篇，主要是关于 lifecycle，livedata 的使用和源码分析，其他的 Navigation， Paging library，Room，WorkMannager 等春节结束以后会更新，欢迎关注个人公众号，有更新的话会第一时间会在公众号上面通知。git

Android lifecycle 使用详解github

Android LiveData 使用详解ide

Android lifecyle 源码解剖源码分析

Android livedata 源码解剖this

github sample 地址： ArchiteComponentsSamplegoogle

Android 技术人，一位不羁的码农。spa

简介

Architecture Components .net

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 的基本使用

引入相关的依赖包

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"

使用

这里一样分为几种状况

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

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;
    }

}

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:");
    }
}

小结：

lifycycle 实际上是用观察者模式实现的，当 Activity 生命周期变化的时候，通知相应的 Observers 即观察者。
使用 lifecycle，咱们能够将释放资源的动做内聚在自身，减小与调用者之间的耦合。

下一篇博客：Android LiveData 使用详解

原文出处：https://www.cnblogs.com/gdutxiaoxu/p/11367658.html