Jetpack Compose过渡 - 监听Acitvity生命周期

本篇过于简陋，学艺不精，请移步第二版：Jetpack Compose生命周期监听（第二版）

事情是这样的

本人学习Compose有两周多了，目前已经着手重构项目上的UI，因为项目体积庞大，要把所有Activity段时间内替换成只有一个Compose的方式肯定不现实，目前就从替换xml布局开始。说实话，用了这么久的View，感觉有些坑挺多，View从反射到绘制需要的时间还是挺长的，经常会遇到因为绘制延迟导致的各式各样的问题，遂决定逐步迁移到Compose上面来。

使用场景

搜索全网，各式各样Compose相关的文章很多，也很详细，根据现有的资料，很难查到关于Activity声明周期监听的文章，因为大多数人都是使用单个Activity + Navigation 的形式。举个例子，在某些场景下，当用户进入新的Activity时，需要默认去请求页面所需的数据，如果在Compose中直接调用，肯定是不行的，根据Compose刷新机制，接口会被疯狂的调用，显然是不合理的，这里我就自己归纳出了一个方法作为过渡。

观察者

自制生命周期观察者，其中 DefaultLifecycleObserver 来自 androidx.lifecycle.DefaultLifecycleObserver

class ComposeLifecycleObserver : DefaultLifecycleObserver {

    private var create: (() -> Unit)? = null

    private var start: (() -> Unit)? = null

    private var resume: (() -> Unit)? = null

    private var pause: (() -> Unit)? = null

    private var stop: (() -> Unit)? = null

    private var destroy: (() -> Unit)? = null
    
    fun onLifeCreate(scope: () -> Unit) {
        this.create = scope
    }
    
    fun onLifeStart(scope: () -> Unit) {
        this.start = scope
    }
    
    fun onLifeResume(scope: () -> Unit) {
        resume = scope
    }
    
    fun onLifePause(scope: () -> Unit) {
        this.pause = scope
    }
    
    fun onLifeStop(scope: () -> Unit) {
        this.stop = scope
    }
    
    fun onLifeDestroy(scope: () -> Unit) {
        this.destroy = scope
    }

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        create?.invoke()
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        start?.invoke()
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        resume?.invoke()
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        pause?.invoke()
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        stop?.invoke()
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        destroy?.invoke()
    }
}

方法

在 Composable 中监听组合状态，一旦组合被释放，就移除声明周期观察

@Composable
fun rememberLifecycle(): ComposeLifecycleObserver {
    val observer = ComposeLifecycleObserver()
    val owner = LocalLifecycleOwner.current

    DisposableEffect(key1 = "lifecycle", effect = {
        owner.lifecycle.addObserver(observer)
        onDispose {
            owner.lifecycle.removeObserver(observer)
        }
    })

    val ctx = LocalContext.current
    return remember(ctx) { observer }
}

使用

在不同的声明周期里做要做的事情即可

@Composable
fun TestScreen(){
    val life = rememberLifecycle()
    life.onLifeCreate { TODO() }
    life.onLifeStart { TODO() }
    life.onLifeResume { TODO() }
    life.onLifePause { TODO() }
    life.onLifeStop { TODO() }
    life.onLifeDestroy { TODO() }
}

最后

非科班跨行程序员，如有错误欢迎批评。