美文网首页
Android JetPack系列之——Lifecycle

Android JetPack系列之——Lifecycle

作者: 乌托邦式的爱情 | 来源:发表于2021-08-31 15:46 被阅读0次

初入Android开发的同学，第一个开始接触的就是四大组件，而在四大组件中第一个必须掌握的技能就是其对应的生命周期，但是很多时候在过往的做法中，我们会将系统组件的生命周期与普通组件耦合在一起，那么，有没有什么办法可以将系统组件的生命周期与普通组件之间分开呢？答案就是使用Jetpack 系列中的Lifecycle。

Lifecycle的简介

LifeCycle 是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service 和 Application。LifeCycle 会持有宿主的生命周期状态的信息，当宿主生命周期发生变化时，会通知监听宿主的观察者。

Lifecycle的优点

  • 降低系统组件（Activity/Fragment、Service 和 Application）和普通组件之间的耦合。
  • 将通用代码从业务层剥离，有利于后期的代码维护和扩展。

Lifecycle的作用场景

1.Activity/Fragment
2.Service
3.Application

在使用LifeCycle的时候，我们需要注意，被观察者需要去实现LifecycleOwner 接口，观察者需要去实现LifecycleObserver 接口。

Lifecycle的应用

1.Lifecycle在Activity/Fragment中的使用

1.添加依赖

implementation 'androidx.appcompat:appcompat:1.2.0'

在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX，还是用的 Support 库，新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。

2.实现观察者

class WorkUtil : LifecycleObserver {

    companion object {
        const val TAG = "LifecycleActivity"
        var whetherToCount = true
        var count = 0
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create(){
        Log.d(TAG, "create：----")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun start() {
        whetherToCount = true
        Thread(Runnable {
            while (whetherToCount) {
                Thread.sleep(1000)
                count++
                Log.d(TAG, "onResume：$count")
            }
        }).start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {
        Log.d(TAG, "onStop：----")
        whetherToCount = false
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {
        whetherToCount = false
        count = 0
        Log.d(TAG, "onDestroy：$count")
    }
}

一般情况下，为了代码的可读性和后期的可扩展性，我们会将可观察者与业务层的代码进行剥离，而触发事件的发送则通过LifeCycle的注解来进行实现。

3.实现被观察者
在Activity中，只要使用的Activity是ComponentActivity及其子类的话，系统就已经默认帮你实现了LifecycleOwner 接口，你可以直接拿到Lifecycle的实例

class LifecycleActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)
        lifecycle.addObserver(WorkUtil())
    }
}

但是如果你直接使用的是Activity的话，则需要你直接注册并进行添加

class LifecycleActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_lifecycle)

        val mLifecycleRegistry = LifecycleRegistry(this)
        mLifecycleRegistry.addObserver(WorkUtil())
    }
}

接下来你会发现，在你运行的时候，每当执行Activity对应的生命周期的方法的时候都会同步执行WorkUtil类中对应的注解所包含的方法。Fragment与Activity写法一致，这里就不过多展示了。

2.Lifecycle在Service中的使用
Lifecycle在Service中的使用与在Activity中的使用类似。
1.添加依赖

implementation "androidx.lifecycle:lifecycle-service:2.2.0"

2.实现观察者

class WorkUtil : LifecycleObserver {

    companion object {
        const val TAG = "LifecycleActivity"
        var whetherToCount = true
        var count = 0
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create(){
        Log.d(TAG, "create：----")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun start() {
        whetherToCount = true
        Thread(Runnable {
            while (whetherToCount) {
                Thread.sleep(1000)
                count++
                Log.d(TAG, "onResume：$count")
            }
        }).start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {
        Log.d(TAG, "onStop：----")
        whetherToCount = false
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {
        whetherToCount = false
        count = 0
        Log.d(TAG, "onDestroy：$count")
    }
}

3.实现被观察者

class MyService : LifecycleService() {

    init {
        lifecycle.addObserver(WorkUtil())
    }
    
}

需要注意的是，在使用Service的时候，不是继承Service类而是继承LifecycleService类。

3.Lifecycle在Application中的使用
1.添加依赖

implementation "androidx.lifecycle:lifecycle-process:2.2.0"

2.实现观察者

class WorkUtil : LifecycleObserver {

    companion object {
        const val TAG = "LifecycleActivity"
        var whetherToCount = true
        var count = 0
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun create(){
        Log.d(TAG, "create：----")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun start() {
        whetherToCount = true
        Thread(Runnable {
            while (whetherToCount) {
                Thread.sleep(1000)
                count++
                Log.d(TAG, "onResume：$count")
            }
        }).start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun stop() {
        Log.d(TAG, "onStop：----")
        whetherToCount = false
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {
        whetherToCount = false
        count = 0
        Log.d(TAG, "onDestroy：$count")
    }
}

3.实现被观察者

class IApplication : Application(), Listener {

    companion object {
        const val TAG = "IApplication"
    }

    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(WorkUtil())
    }
}
总结：其实Lifecycle相对来说使用起来非常的简单，并没有太多高深的东西，其主要使用的就是配合注解达到实现监听的效果。其真正的核心在于在实际的应用开发过程中如何与业务组件进行解耦，我觉得这是使用Lifecycle需要好好去思考的问题。

最后附上一个实现监听APP位于前台与后台的小功能

第一步：创建一个接口用于APP状态的设置

/**
 * @author: zhoufan
 * @date:   2021/8/31 11:19
 */
interface Listener {
    /**
     * APP位于前台
     */
    fun onBecomeForeground()

    /**
     * APP位于后台
     */
    fun onBecomeBackground()
}

第二步：创建一个类实现对Activity的状态的监听

/**
 * @author: zhoufan
 * @date:   2021/8/31 11:10
 * 监听 Activity的生命周期的方法
 * 同步判断APP前台后台的状况
 */
class ForegroundCallbacks : Application.ActivityLifecycleCallbacks {

    private var runnable: Runnable? = null
    private var handler: Handler? = null
    private var onResume = false
    private var onPause = true
    private var listener: Listener? = null

    fun addListener(listener: Listener) {
        this.listener = listener
        handler = Handler(Looper.myLooper()!!)
    }

    companion object {
        const val TAG = "ForegroundCallbacks"
        private var instance: ForegroundCallbacks? = null
        fun init(appApplication: IApplication): ForegroundCallbacks {
            instance = ForegroundCallbacks()
            appApplication.registerActivityLifecycleCallbacks(instance)
            return instance!!
        }
    }

    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        Log.d(TAG, "onActivityCreated: ${activity.componentName}")
    }

    override fun onActivityStarted(activity: Activity) {
        Log.d(TAG, "onActivityStarted: ${activity.componentName}")
    }

    override fun onActivityResumed(activity: Activity) {
        Log.d(TAG, "onActivityResumed: ${activity.componentName}")
        onPause = false
        runnable?.run {
            handler?.removeCallbacks(this)
        }
        handler?.postDelayed(Runnable {
            if (!onResume) {
                onResume = true
                listener?.onBecomeForeground()
            }
        }.also { runnable = it }, 600)
    }

    override fun onActivityPaused(activity: Activity) {
        Log.d(TAG, "onActivityPaused: ${activity.componentName}")
        onPause = true
        runnable?.run {
            handler?.removeCallbacks(this)
        }
        handler?.postDelayed(Runnable {
            if (onResume && onPause) {
                onResume = false
                listener?.onBecomeBackground()
            }
        }.also { runnable = it }, 600)
    }

    override fun onActivityStopped(activity: Activity) {
        Log.d(TAG, "onActivityStopped: ${activity.componentName}")
    }

    override fun onActivityDestroyed(activity: Activity) {
        Log.d(TAG, "onActivityDestroyed: ${activity.componentName}")
    }

    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
        Log.d(TAG, "onActivitySaveInstanceState: ${activity.componentName}")
    }
}

第三步：在我们的Application里面设置对应的监听

class IApplication : Application(), Listener {

    companion object {
        const val TAG = "IApplication"
    }

    override fun onCreate() {
        super.onCreate()
        // 设置监听
        ForegroundCallbacks.init(this).addListener(this)
    }

    override fun onBecomeForeground() {
        Log.d(TAG, "onBecameForeground: 在前台")
    }

    override fun onBecomeBackground() {
        Log.d(TAG, "onBecameForeground: 在后台")
    }
}

相关文章

网友评论

      本文标题：Android JetPack系列之——Lifecycle

      本文链接：https://www.haomeiwen.com/subject/iisziltx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Android JetPack系列之——Lifecycle|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！