Timer logic defined using the coroutines

ProgressTimer.kt

class ProgressTimer(
    private val player: Player,
    private val positionListener: PositionListener,
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
 )  {

    companion object {
        const val PROGRESS_TRACK_DURATION : Long = 1000
    }

    private val coroutineContext = CoroutineScope(ioDispatcher + SupervisorJob())

    interface PositionListener {
        fun progress(position: Long)
    }

    init {
        startTimer()
    }

    private fun startTimer() {
        coroutineContext.launch {
            launchPeriodicAsync(PROGRESS_TRACK_DURATION) {
                launch {
                    val result = withContext(Dispatchers.Main) {
                        return@withContext player.currentPosition
                    }
                    positionListener.progress(result)
                }
            }.join()
        }
    }

    private fun CoroutineScope.launchPeriodicAsync(
        repeatMillis: Long,
        action: () -> Unit
    ) = this.launch {
        if (repeatMillis > 0) {
            while (isActive) { action()
                delay(repeatMillis)
            }
        } else { action() }
    }


    fun purgeTimer() {
        coroutineContext.cancel()
    }
}

StartingTimer.kt

fun startingTimer() {
    val progressTracker = ProgressTimer(it, (object : ProgressTimer.PositionListener {
        override fun progress(position: Long) {
            // -- > This is called on every interval
        }
    }), Dispatchers.IO)
}

StoppingTimer.kt

progressTracker.purgeTimer();