Kotlin: llamar a una función cada segundo

Quiero crear una cuenta regresiva simple para mi juego, cuando el juego comience, quiero que se llame a esta función cada segundo:

fun minusOneSecond(){
  if secondsLeft > 0{
     secondsLeft -= 1
     seconds_thegame.text = secondsLeft.toString()
  }
}

Intenté esto:

var secondsLeft = 15

timer.scheduleAtFixedRate(
   object : TimerTask() {

      override fun run() {
         minusOneSecond()
      }

    },0, 1000
)   // 1000 Millisecond  = 1 second

Pero, lamentablemente, la aplicación se detiene, la segunda vez que se llama a la función de ejecución

Empecé con el desarrollo de Android y Kotlin hace 3 semanas y hasta ahora lo entiendo al máximo.

Con swift en Xcode uso esta línea y pensé que algo similar funcionaría con Kotlin

setTimer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(minusOneSecond), userInfo: nil, repeats: true)

Problema: Temporizador class usa un subproceso de fondo con una cola para poner en cola y ejecutar todas las tareas secuencialmente. Desde su código, porque actualiza la interfaz de usuario (cambiando el contenido de TextView en minusOneSecond función). Es por eso que la aplicación lanza la siguiente excepción y hace que su aplicación se bloquee.

android.view.ViewRootImpl$CalledFromWrongThreadException: solo el subproceso original que creó una jerarquía de vistas puede tocar sus vistas.

Solución: Hay muchas maneras de lograr su tarea, pero prefiero usar correo() y postretrasado() método de Manipulador clase. Porque es simple y fácil de entender.

val mainHandler = Handler(Looper.getMainLooper())

mainHandler.post(object : Runnable {
    override fun run() {
        minusOneSecond()
        mainHandler.postDelayed(this, 1000)
    }
})

Actualizar: Del comentario del autor sobre cómo pausar/reanudar la tarea de Handler. Aquí hay un ejemplo.

class MainActivityKt : AppCompatActivity() {

    lateinit var mainHandler: Handler

    private val updateTextTask = object : Runnable {
        override fun run() {
            minusOneSecond()
            mainHandler.postDelayed(this, 1000)
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // Your logic code
        ...
        mainHandler = Handler(Looper.getMainLooper())
    }

    override fun onPause() {
        super.onPause()
        mainHandler.removeCallbacks(updateTextTask)
    }

    override fun onResume() {
        super.onResume()
        mainHandler.post(updateTextTask)
    }

    fun minusOneSecond() {
        if secondsLeft > 0 {
            secondsLeft -= 1
            seconds_thegame.text = secondsLeft.toString()
        }
    }
}

Estoy usando este código para actualizar un reloj cada minuto.

 fixedRateTimer("timer", false, 0L, 60 * 1000) {
     this@FullscreenActivity.runOnUiThread {
         tvTime.text = SimpleDateFormat("dd MMM - HH:mm", Locale.US).format(Date())
     }
 }

así que tienes que ejecutarlo con paratemer 1000 en vez de 60*1000

val timer = object: CountDownTimer(10000, 1000) {
    override fun onTick(millisUntilFinished: Long) {
        // do something
    }
    override fun onFinish() {
        // do something
    }
}
timer.start()

También puede usar CountDownTimer para este propósito. Como esto toma dos parámetros (el tiempo total y el intervalo de tiempo)

Además, también proporciona un método de finalización para realizar cualquier tarea cuando finaliza el tiempo total.

por favor use

inline fun Timer.schedule(
    time: Date, 
    period: Long, 
    crossinline action: TimerTask.() -> Unit
): TimerTask

referencia: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.concurrent/java.util.-timer/schedule.html

Estoy llamando a mi función cada segundo así

val handler = Handler()
  handler.postDelayed(object : Runnable {
      override fun run() {
            //Call your function here
            handler.postDelayed(this, 1000)//1 sec delay
        }
}, 0)

Mi solución

viewModelScope.launch(Dispatchers.IO) {
            while(isActive) {
                when(val response = repository.getApi()) {
                    is NetworkState.Success -> {
                        getAllData.postValue(response.data)
                    }
                    is NetworkState.Error -> this@MainViewModel.isActive = false
                }

                delay(API_CALL_DELAY)
            }
        }

Estoy usando recursividad con Coroutine es muy simple

  private fun loop() {
    CoroutineScope(IO).launch {
        delay(5000)
        CoroutineScope(Main).launch {
            ManagerToWorker()
            loop()
        }
    }
}