Android lifecycle 使用详解

ゝ一纸荒年。 2022-03-22 07:12 200阅读 0赞

## 说在前面 ##

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

[Android lifecycle 使用详解][Android lifecycle]

[Android LiveData 使用详解][Android LiveData]

[Android lifecyle 源码解剖][Android lifecyle]

[Android livedata 源码解剖][Android livedata]

[github sample 地址： ArchiteComponentsSample][github sample _ ArchiteComponentsSample]

**程序员徐公**，五年中大厂开发经验，助你升职加薪，带你走进大厂

1.  公众号程序员徐公回复**黑马**，获取 Android 学习视频
2.  公众号程序员徐公回复**徐公666**，获取简历模板，教你如何优化简历，走进大厂
3.  公众号程序员徐公回复**面试**，可以获得面试常见算法，剑指 offer 题解
4.  公众号程序员徐公回复**马士兵**，可以获得马士兵学习视频一份

![程序员徐公][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]

[Architecture Components ][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 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"

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

小结：

1.  lifycycle 其实是用观察者模式实现的，当 Activity 生命周期变化的时候，通知相应的 Observers 即观察者。
2.  使用 lifecycle，我们可以将释放资源的动作内聚在自身，减少与调用者之间的耦合。

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

## 推荐阅读 ##

[Android 启动优化（一） - 有向无环图][Android _ -]

[Android 启动优化（二） - 拓扑排序的原理以及解题思路][Android _ - 1]

[Android 启动优化（三）- AnchorTask 开源了][Android _- AnchorTask]

[Android 启动优化（四）- AnchorTask 是怎么实现的][Android _- AnchorTask 1]

[Android 启动优化（五）- AnchorTask 1.0.0 版本正式发布了][Android _- AnchorTask 1.0.0]

[Android 启动优化（六）- 深入理解布局优化][Android _-]

这几篇文章从 0 到 1，讲解 DAG 有向无环图是怎么实现的，以及在 Android 启动优化的应用。

**推荐理由：现在挺多文章一谈到启动优化，动不动就聊拓扑结构，这篇文章从数据结构到算法、到设计都给大家说清楚了，开源项目也有非常强的借鉴意义。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70 1]

[Android lifecycle]: https://blog.csdn.net/gdutxiaoxu/article/details/86660746
[Android LiveData]: https://blog.csdn.net/gdutxiaoxu/article/details/86660760
[Android lifecyle]: https://blog.csdn.net/gdutxiaoxu/article/details/86660766
[Android livedata]: https://blog.csdn.net/gdutxiaoxu/article/details/86660776
[github sample _ ArchiteComponentsSample]: https://github.com/gdutxiaoxu/ArchiteComponentsSample
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]: /images/20220322/269bb42cf987421790c48c5b5fd38fd1.png
[Architecture Components]: https://developer.android.com/topic/libraries/architecture/
[Android _ -]: https://mp.weixin.qq.com/s/xWYe-uxgXTPuitYcLgXYNg
[Android _ - 1]: https://mp.weixin.qq.com/s/ShfxD_Z7M_NuWYNodn-vqA
[Android _- AnchorTask]: https://mp.weixin.qq.com/s/YRUpf9jKEwIHV0A4FqltXg
[Android _- AnchorTask 1]: https://mp.weixin.qq.com/s/6RKco9JTm6ZrFyw99k9Rlg
[Android _- AnchorTask 1.0.0]: https://mp.weixin.qq.com/s/0MsJa0ZepWkPUs-ymnVb-w
[Android _-]: https://mp.weixin.qq.com/s/7_dQd2wGZYKWf9kHNlv2fg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70 1]: /images/20220322/38c25daf376a4581aa4b851a98de1322.png