CancelOnLifecycleStopAndRetryOnStartApiCallbackTask.kt

fun resolveDeepLink(
    lifecycleScope: LifecycleCoroutineScope,
    lifecycle: Lifecycle,
    handler: DefaultScreenDeepLinkHandler,
    provider: String,
    json: JSONObject,
) {
    val cancellable = cancelOnLifecycleStopAndRetryOnStartApiCallbackTask<Boolean>(
        lifecycle, lifecycleScope, {
            // Do something with result
        }) { handler.resolveDeepLink(provider, json, it) }
    cancellable.cancel()
}

interface Cancellable {
    fun cancel()
}

class CancelOnLifecycleStopAndRetryOnStartApiCallbackTask<T> private constructor (
    private val lifecycle: Lifecycle,
    private val coroutineScope: CoroutineScope,
    callback: (T) -> Unit,
    private val api: suspend ((T) -> Unit) -> Unit
) : DefaultLifecycleObserver, Cancellable {

    private var job: Job? = null
    private var result: T? = null

    private val update = { t: T ->
        t.also {
            result = it
            removeObserver()
        }
    }.andThen(callback)

    private fun resolveDeepLink() {
        job = coroutineScope.launch {
            api(update)
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        resetJob()
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        if (job == null) resolveDeepLink()
    }

    private fun removeObserver() = lifecycle.removeObserver(this)

    override fun cancel() {
        if (result != null) return
        resetJob()
        removeObserver()
    }

    private fun resetJob() {
        job?.cancel()
        job = null
    }

    companion object {

        fun <T> cancelOnLifecycleStopAndRetryOnStartApiCallbackTask(
            lifecycle: Lifecycle,
            coroutineScope: CoroutineScope,
            callback: (T) -> Unit,
            api: suspend ((T) -> Unit) -> Unit
        ): Cancellable {
            val task = CancelOnLifecycleStopAndRetryOnStartApiCallbackTask(
                lifecycle,
                coroutineScope,
                callback,
                api)
            lifecycle.addObserver(task)
            return task
        }
    }
}