Android JetPack系列之——Lifecycle

初入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: 在后台")
    }
}
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 211,817评论 6 492
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,329评论 3 385
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 157,354评论 0 348
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,498评论 1 284
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 65,600评论 6 386
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,829评论 1 290
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,979评论 3 408
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,722评论 0 266
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,189评论 1 303
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,519评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,654评论 1 340
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,329评论 4 330
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,940评论 3 313
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,762评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,993评论 1 266
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,382评论 2 360
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,543评论 2 349

推荐阅读更多精彩内容