Android开发 Jetpack_LifeCycle 生命周期监听详解

版权声明

本文来自博客园，作者：观心静 ，转载请注明原文链接：https://www.cnblogs.com/guanxinjing/p/16884287.html

本文版权归作者和博客园共有，欢迎转载，但必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。

前言

LifeCycle的简单说明，引用google。

生命周期感知型组件可执行操作来响应另一个组件（如 activity 和 fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。

　　说白了就是监听Activity与Fragment的生命周期，这里有新人会疑问，Activity与Fragment都有自带生命周期的方法，为什么要在Jetpack系列里额外增加一个LifeCycle来监听生命周期呢？

　　其实google的目的可以浓缩成几个字总结" 规范、解耦、防止内存泄漏 "。怎么理解呢？ 下面一一说明。

1.这里的规范是指希望开发人员摒弃自己创建的各种生命周期观察者监控管理类，统一使用LifeCycle。 

2. 这里的解耦是指对Activity与Fragment与之相对的业务代码进行解耦。为什么要对Activity与Fragment的业务代码进行解耦？ 在复杂的页面将各种网络请求、数据库操作、数据整理封装统统都放到Activity与Fragment里进行处理，并不优美，因为Activity与Fragment的定义是View层(视图层)。他们更应当简单、清晰的只实现与UI视图有关的代码。

3. 防止内存泄漏这个怎么理解呢？ 在原来Activity与Fragment的自身的生命周期方法里，其实并不细致。特别是对Activity与Fragment的销毁上原来生命周期并不能很好的感知到。这点在Activity或者Fragment里进行资源释放的时候很容易能体会到。 有时候Activity已经马上要销毁了，但是onStart的初始化资源代码可能还在执行，在或者onDestroy的注销资源代码还在执行。这个时候Activity的释放就需要等待这些生命周期的代码执行完成，从而容易导致内存泄漏。 哪怕有isFinishing() 与 isDetached()方法，依然无法完全避免这种问题。依靠isFinishing()来决定释放资源并不完美,还有种情况可以跳过清理的,那就是SingleTask模式下这个Activity要被销毁,但是后台因为入栈(入深栈最少在第三层的那种情况)已经触发过onPause或者onStop,所以SingleTask的清理就跳过了isFinishing()判断,直接走到了onDestroy()。 有了以上种种情况举例，你可以感觉到在Activity里进行资源的初始化与释放工作其实是已经特别笨重的动作，特别是销毁的时候把大量工作都只能堆积到onDestroy以确保资源完美释放。而LifeCycle可以与Activity的关联一击脱离，让在LifeCycle里的资源释放代码与Activity销毁形成异步流程。

 

 　　以上说了这么多废话LifeCycle好处又这么多，是不是代表以后需要经常使用LifeCycle？不！ LifeCycle其实在一般开发的情况下使用很少，我们一般会大量使用基于LifeCycle实现的ViewModel、LiveData与MutableLiveData处理网络请求、数据库操作等等业务。但是，了解LifeCycle还是非常重要的。因为有一些场合你是一定需要LifeCycle的，特别是kotlin协程的异步、将LifeCycle作为Activity的Base类，统一处理一部分Activity需要复用性UI代码(比如隐藏状态栏，显示通用性加载对话框等等)

LifeCycle的使用

class DemoActivity : AppCompatActivity() {
    private lateinit var mMyLifecycleObserver: MyLifecycleObserver
    private lateinit var mDefaultLifecycleObserver: DefaultLifecycleObserver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_demo)
        findViewById<Button>(R.id.finishButton).setOnClickListener {
            finish()
        }
        Log.e("zh", "onCreate:当前的生命周期 ${lifecycle.currentState}")
        /**
         * 自定义的生命周期观察
         */
        mMyLifecycleObserver = MyLifecycleObserver()
        lifecycle.addObserver(mMyLifecycleObserver)


        /**
         * 默认的生命周期观察
         */
        mDefaultLifecycleObserver = object : DefaultLifecycleObserver {
            override fun onCreate(owner: LifecycleOwner) {
                super.onCreate(owner)

            }

            override fun onDestroy(owner: LifecycleOwner) {
                super.onDestroy(owner)
            }
        }
        lifecycle.addObserver(mDefaultLifecycleObserver)
    }


    override fun onStop() {
        super.onStop()
        /**
         * 移除观察者，请注意一点，观察者的移除并不是必要的。因为不移除也不会引起Activity的内存泄漏。Activity在释放的时候会将lifecycle全部清理
         * 而移除观察的意义是某个情况下如果你不需要观察生命周期了，你可以调用removeObserver清除观察。
         */
        lifecycle.removeObserver(mMyLifecycleObserver)
        lifecycle.removeObserver(mDefaultLifecycleObserver)
    }

}

/**
 * 自定义生命周期观察class
 */
class MyLifecycleObserver : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        Log.e("zh", "当前的生命周期 : ${event.targetState}")
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                Log.e("zh", "ON_CREATE")
            }
            Lifecycle.Event.ON_START -> {
                Log.e("zh", "ON_START")
            }
            Lifecycle.Event.ON_RESUME -> {
                Log.e("zh", "ON_RESUME")
            }
            Lifecycle.Event.ON_PAUSE -> {
                Log.e("zh", "ON_PAUSE")
            }
            Lifecycle.Event.ON_STOP -> {
                Log.e("zh", "ON_STOP")
            }
            Lifecycle.Event.ON_DESTROY -> {
                Log.e("zh", "ON_DESTROY")
            }
            Lifecycle.Event.ON_ANY -> {
                Log.e("zh", "ON_ANY")
            }
        }
        //与协程的配合
        source.lifecycle.coroutineScope.launch {
            source.whenCreated {
                Log.e("zh", "whenCreated")
            }
            source.whenStarted {
                Log.e("zh", "whenStarted")
            }
            source.whenResumed {
                Log.e("zh", "whenResumed")
            }
        }
        //与协程的配合
        source.lifecycleScope.launchWhenCreated {
            Log.e("zh", "whenCreated")
        }
    }

}

复用性操作状态栏例子

上面的例子只是告诉你有什么功能，这个例子才是告诉你LifeCycle其中一部分的意义。在操作状态栏功能，我们经常会在BaseActivity里实现，但是BaseActivity其实应该尽量精简。但是我们如果把此功能单独拿到LifeCycle里实现就可以满足复用性与代码隔离的2个需求。

class DemoActivity : AppCompatActivity() {
    private lateinit var mHideNavigationBarWindow: HideNavigationBarWindow

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_demo)
        findViewById<Button>(R.id.finishButton).setOnClickListener {
            finish()
        }
        mHideNavigationBarWindow = HideNavigationBarWindow(this, true)
        lifecycle.addObserver(mHideNavigationBarWindow)
    }

}

/**
 * 状态栏生命周期操作类
 */
class HideNavigationBarWindow(val activity: AppCompatActivity,val isShow:Boolean) : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        if (event == Lifecycle.Event.ON_CREATE) {
            if (isShow){
                show()
            } else {
                hide()
            }
        }
    }

    fun show(){
        val windowController = WindowCompat.getInsetsController(activity.window, activity.window.decorView)
        windowController.show(WindowInsetsCompat.Type.statusBars())
    }

    fun hide(){
        val windowController = WindowCompat.getInsetsController(activity.window, activity.window.decorView)
        windowController.hide(WindowInsetsCompat.Type.statusBars())
    }

}

复用性对话框例子

这个例子可以告诉你LifeCycle最有意义的使用场景，满足复用性、代码隔离、防止泄漏、控制生命周期。

class DemoActivity : AppCompatActivity() {
    private lateinit var mTipsDialogLifecycleWindow: TipsDialogLifecycleWindow

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_demo)
        findViewById<Button>(R.id.finishButton).setOnClickListener {
            finish()
        }
        mTipsDialogLifecycleWindow = TipsDialogLifecycleWindow(this, "温馨提示", "这是一个对话框")
        mTipsDialogLifecycleWindow.show()
    }
}

/**
 * 提示对话框
 */
class TipsDialogLifecycleWindow(val activity: AppCompatActivity, val title: String, val message: String) : LifecycleEventObserver {
    private lateinit var mTipsDialog: AlertDialog
    private var mIsShow = true

    init {
        mTipsDialog = AlertDialog.Builder(activity)
            .setTitle(title)
            .setMessage(message)
            .create()
        activity.lifecycle.addObserver(this)
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME -> {
                mIsShow = true
            }
            Lifecycle.Event.ON_DESTROY -> {
                mIsShow = false
                dismiss()
            }
            Lifecycle.Event.ON_STOP -> mIsShow = false
            else -> {}
        }
    }

    fun show() {
        if (!mIsShow) {
            return
        }
        mTipsDialog.show()
    }

    fun dismiss() {
        mTipsDialog.dismiss()
    }
}

 

 

End