So implementieren Sie Timer mit Kotlin-Coroutinen

Ich möchte Timer mit Kotlin-Coroutinen implementieren, ähnlich wie bei RxJava:

       Flowable.interval(0, 5, TimeUnit.SECONDS)
                    .observeOn(AndroidSchedulers.mainThread())
                    .map { LocalDateTime.now() }
                    .distinctUntilChanged { old, new ->
                        old.minute == new.minute
                    }
                    .subscribe {
                        setDateTime(it)
                    }

Es wird LocalDateTime jede neue Minute ausgeben.

Bearbeiten: Beachten Sie, dass die in der ursprünglichen Antwort vorgeschlagene API jetzt markiert ist @ObsoleteCoroutineApi:

Tickerkanäle sind derzeit nicht in die strukturierte Parallelität integriert und ihre API wird sich in Zukunft ändern.

Sie können jetzt die verwenden Flow API zum Erstellen Ihres eigenen Ticker-Flows:

import kotlin.time.Duration
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun tickerFlow(period: Duration, initialDelay: Duration = Duration.ZERO) = flow {
    delay(initialDelay)
    while (true) {
        emit(Unit)
        delay(period)
    }
}

Und Sie können es auf eine Weise verwenden, die Ihrem aktuellen Code sehr ähnlich ist:

tickerFlow(5.seconds)
    .map { LocalDateTime.now() }
    .distinctUntilChanged { old, new ->
        old.minute == new.minute
    }
    .onEach {
        setDateTime(it)
    }
    .launchIn(viewModelScope) // or lifecycleScope or other

Hinweis: Bei dem hier geschriebenen Code wird die Zeit, die zum Verarbeiten von Elementen benötigt wird, nicht berücksichtigt tickerFlowdaher ist die Verzögerung möglicherweise nicht regelmäßig (es ist eine Verzögerung zwischen Elementverarbeitung). Wenn Sie möchten, dass der Ticker unabhängig von der Verarbeitung jedes Elements tickt, können Sie a verwenden Puffer oder einen eigenen Thread (zB via flowOn).

Ursprüngliche Antwort

Ich glaube, es ist noch experimentell, aber Sie können a verwenden TickerChannel um Werte alle X Millis zu erzeugen:

val tickerChannel = ticker(delayMillis = 60_000, initialDelayMillis = 0)

repeat(10) {
    tickerChannel.receive()
    val currentTime = LocalDateTime.now()
    println(currentTime)
}

Wenn Sie Ihre Arbeit fortsetzen müssen, während Ihr “Abonnement” für jeden “Tick” etwas tut, können Sie das tun launch eine Hintergrund-Coroutine, die von diesem Kanal liest und das tut, was Sie wollen:

val tickerChannel = ticker(delayMillis = 60_000, initialDelayMillis = 0)

launch {
    for (event in tickerChannel) {
        // the 'event' variable is of type Unit, so we don't really care about it
        val currentTime = LocalDateTime.now()
        println(currentTime)
    }
}

delay(1000)

// when you're done with the ticker and don't want more events
tickerChannel.cancel()

Wenn Sie innerhalb der Schleife anhalten möchten, können Sie einfach ausbrechen und dann den Kanal abbrechen:

val ticker = ticker(500, 0)

var count = 0

for (event in ticker) {
    count++
    if (count == 4) {
        break
    } else {
        println(count)
    }
}

ticker.cancel()

Ein sehr pragmatischer Ansatz mit Kotlin Flows könnte sein:

// Create the timer flow
val timer = (0..Int.MAX_VALUE)
    .asSequence()
    .asFlow()
    .onEach { delay(1_000) } // specify delay

// Consume it
timer.collect { 
    println("bling: ${it}")
}

eine weitere mögliche Lösung als wiederverwendbare Kotlin-Erweiterung von CoroutineScope

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

und dann Verwendung als:

var job = CoroutineScope(Dispatchers.IO).launchPeriodicAsync(100) {
  //...
}

und um es dann zu unterbrechen:

job.cancel()

noch eine Anmerkung: wir betrachten das hier action ist nicht blockierend und nimmt keine Zeit in Anspruch.

Sie können einen Countdown-Timer wie diesen erstellen

GlobalScope.launch(Dispatchers.Main) {
            val totalSeconds = TimeUnit.MINUTES.toSeconds(2)
            val tickSeconds = 1
            for (second in totalSeconds downTo tickSeconds) {
                val time = String.format("%02d:%02d",
                    TimeUnit.SECONDS.toMinutes(second),
                    second - TimeUnit.MINUTES.toSeconds(TimeUnit.SECONDS.toMinutes(second))
                )
                timerTextView?.text = time
                delay(1000)
            }
            timerTextView?.text = "Done!"
        }

Bearbeiten: Joffrey hat seine Lösung mit einem besseren Ansatz bearbeitet.

Alt :

Joffreys Lösung funktioniert für mich, aber ich bin auf ein Problem mit der for-Schleife gestoßen.

Ich muss meinen Ticker in der for-Schleife wie folgt löschen:

            val ticker = ticker(500, 0)
            for (event in ticker) {
                if (...) {
                    ticker.cancel()
                } else {
                    ...
                    }
                }
            }

Aber ticker.cancel() hat eine CancellationException ausgelöst, weil die for-Schleife danach weiterging.

Ich musste eine While-Schleife verwenden, um zu überprüfen, ob der Kanal nicht geschlossen wurde, um diese Ausnahme nicht zu erhalten.

                val ticker = ticker(500, 0)
                while (!ticker.isClosedForReceive && ticker.iterator().hasNext()) {
                    if (...) {
                        ticker.cancel()
                    } else {
                        ...
                        }
                    }
                }

Hier ist eine mögliche Lösung mit Kotlin Flow

fun tickFlow(millis: Long) = callbackFlow<Int> {
    val timer = Timer()
    var time = 0
    timer.scheduleAtFixedRate(
        object : TimerTask() {
            override fun run() {
                try { offer(time) } catch (e: Exception) {}
                time += 1
            }
        },
        0,
        millis)
    awaitClose {
        timer.cancel()
    }
}

Verwendungszweck

val job = CoroutineScope(Dispatchers.Main).launch {
   tickFlow(125L).collect {
      print(it)
   }
}

...

job.cancel()

Timer mit START-, PAUSE- und STOP-Funktion.

Verwendungszweck:

val timer = Timer(millisInFuture = 10_000L, runAtStart = false)
timer.start()

Timer Klasse:

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow

enum class PlayerMode {
    PLAYING,
    PAUSED,
    STOPPED
}

class Timer(
    val millisInFuture: Long,
    val countDownInterval: Long = 1000L,
    runAtStart: Boolean = false,
    val onFinish: (() -> Unit)? = null,
    val onTick: ((Long) -> Unit)? = null
) {
    private var job: Job = Job()
    private val _tick = MutableStateFlow(0L)
    val tick = _tick.asStateFlow()
    private val _playerMode = MutableStateFlow(PlayerMode.STOPPED)
    val playerMode = _playerMode.asStateFlow()

    private val scope = CoroutineScope(Dispatchers.Default)

    init {
        if (runAtStart) start()
    }

    fun start() {
        if (_tick.value == 0L) _tick.value = millisInFuture
        job.cancel()
        job = scope.launch(Dispatchers.IO) {
            _playerMode.value = PlayerMode.PLAYING
            while (isActive) {
                if (_tick.value <= 0) {
                    job.cancel()
                    onFinish?.invoke()
                    _playerMode.value = PlayerMode.STOPPED
                    [email protected]
                }
                delay(timeMillis = countDownInterval)
                _tick.value -= countDownInterval
                onTick?.invoke([email protected]._tick.value)
            }
        }
    }

    fun pause() {
        job.cancel()
        _playerMode.value = PlayerMode.PAUSED
    }

    fun stop() {
        job.cancel()
        _tick.value = 0
        _playerMode.value = PlayerMode.STOPPED
    }
}

Ich habe mich inspirieren lassen hier.