waitForLifecycleEvent

Lifecycle+Extensions.kt

@OptIn(ExperimentalCoroutinesApi::class)
suspend fun Lifecycle.waitForLifecycleEvent(event: Lifecycle.Event) = suspendCancellableCoroutine<Unit> { continuation ->

    val observer = object : DefaultLifecycleObserver {

        override fun onCreate(owner: LifecycleOwner) {
            super.onCreate(owner)
            if (event != Lifecycle.Event.ON_CREATE) return
            continuationResume()
        }

        override fun onStart(owner: LifecycleOwner) {
            super.onStart(owner)
            if (event != Lifecycle.Event.ON_START) return
            continuationResume()
        }

        override fun onResume(owner: LifecycleOwner) {
            super.onResume(owner)
            if (event != Lifecycle.Event.ON_RESUME) return
            continuationResume()
        }

        override fun onPause(owner: LifecycleOwner) {
            super.onPause(owner)
            if (event != Lifecycle.Event.ON_PAUSE) return
            continuationResume()
        }

        override fun onStop(owner: LifecycleOwner) {
            super.onStop(owner)
            if (event != Lifecycle.Event.ON_STOP) return
            continuationResume()
        }

        override fun onDestroy(owner: LifecycleOwner) {
            super.onDestroy(owner)
            if (event != Lifecycle.Event.ON_DESTROY) return
            continuationResume()
        }

        private fun continuationResume() {
            continuation.resume(Unit) {
                ProfiLogger.i(it.message.orEmpty())
            }
            removeObserver(this)
        }
    }

    addObserver(observer)

    continuation.invokeOnCancellation {
        removeObserver(observer)
    }
}