Coroutine-based solution for delayed and periodic work

CoroutineTimer.kt

/**
 * Coroutine-based solution for delayed and periodic work. May fire once (if [interval] omitted)
 * or periodically ([startDelay] defaults to [interval] in this case), replacing both
 * `Observable.timer()` & `Observable.interval()` from RxJava.
 *
 * In contrast to RxJava, intervals are calculated since previous run completion; this is more
 * convenient for potentially long work (prevents overlapping) and does not suffer from queueing
 * multiple invocations in Doze mode on Android.
 *
 * Dispatcher is inherited from scope, may be overridden via [context] parameter.
 *
 * Inspired by [https://github.com/Kotlin/kotlinx.coroutines/issues/1186#issue-443483801]
 */
@ExperimentalTime
fun CoroutineScope.timer(
    interval: Duration = Duration.ZERO,
    startDelay: Duration = interval,
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend () -> Unit
): Job = launch(context) {
    delay(startDelay)
    do {
        block()
        delay(interval)
    } while (interval > Duration.ZERO)
}

/** Variant of [timer] with intervals (re)calculated since the beginning (like in RxJava), for cases
 *  where accumulating time shift due to [delay] non-exactness & time spent in [block] is undesirable */
@ExperimentalTime
fun CoroutineScope.timerExact(
    interval: Duration = Duration.ZERO,
    startDelay: Duration = interval,
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend () -> Unit
): Job = launch(context) {
    val startTime = TimeSource.Monotonic.markNow()
    var count: Long = 0
    delay(startDelay)
    do {
        block()
        // Long to Double conversion is generally lossy, but values up to 2^53 (285 million years
        // for 1-second intervals) will be represented exactly, see https://stackoverflow.com/a/1848762
        val nextTime = startTime + startDelay + interval * (++count).toDouble()
        delay(nextTime.remaining())
    } while (interval > Duration.ZERO)
}

/** Returns the amount of time remaining until this mark (opposite of [TimeMark.elapsedNow]) */
@ExperimentalTime
fun TimeMark.remaining(): Duration = -elapsedNow()

Please can i get usage example of this? Tried using it in a viewModelScope and it's not getting called

In the most typical case (run every N seconds/minutes), it would be something like this:

viewModelScope.timer(interval = 10.seconds) { Log.i(TAG, "timer ticked") }

If you need the first run to happen immediately, it would be timer(startDelay = Duration.ZERO, interval = 10.seconds) { ... }
For one-off task with delay, it's timer(startDelay = 10.seconds) { ... }

I often use it with viewModelScope, seems to work fine. :) If you still have an issue and can share your code, I'll try to look into it.

Thank you so much for taking the time to explain. I found recursion to be more suited for the problem I was trying to fix.

Sure, it depends on your use case. If you're just retrying some operation on failure, you may find my runRetrying useful. For more tricky cases recursion seems to be an elegant solution, but please be aware that with infinite retries it causes a memory leak and will crash sooner or later.