Added Duration support

Author: scrinoman

app/build.gradle

@@ -11,6 +11,11 @@ android {
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+        kotlinOptions.freeCompilerArgs += [
+                "-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi",
+                "-Xuse-experimental=kotlinx.coroutines.ObsoleteCoroutinesApi",
+                "-Xuse-experimental=kotlin.time.ExperimentalTime"]
     }
     buildTypes {
         release {
@@ -26,6 +31,7 @@ dependencies {
     implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation "androidx.appcompat:appcompat:$appcompat"
     implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9'
 
     testImplementation 'junit:junit:4.13.1'
     androidTestImplementation 'com.android.support.test:runner:1.0.2'

app/src/main/java/omega_r/com/extensions/simple/MainActivity.kt

@@ -2,12 +2,50 @@ package omega_r.com.extensions.simple
 
 import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
+import android.util.Log
+import com.omega_r.libs.extensions.coroutines.launchDelayed
+import com.omega_r.libs.extensions.coroutines.launchWithTicker
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlin.time.DurationUnit
+import kotlin.time.seconds
 
 class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+
+        CoroutineScope(Dispatchers.Default).apply {
+            launchDelayed(4900) {
+                Log.d("MainActivity", "launchDelayed(4900)")
+            }
+            launchDelayed(5.seconds) {
+                Log.d("MainActivity", "launchDelayed(5.seconds)")
+            }
+            launchWithTicker(
+                ticksCount = 10,
+                tickDurationMillis = 1000,
+                initialDelayMillis = 5000,
+                onTick = {
+                    Log.d("MainActivity", "launchWithTicker($it)")
+                },
+                onEnd = {
+                    Log.d("MainActivity", "launchWithTicker(end)")
+                }
+            )
+            launchWithTicker(
+                ticksCount = 10,
+                tickDuration = 1.seconds,
+                initialDelay = 15.seconds,
+                onTick = {
+                    Log.d("MainActivity", "launchWithTicker2($it)")
+                },
+                onEnd = {
+                    Log.d("MainActivity", "launchWithTicker2(end)")
+                }
+            )
+        }
     }
 
 }

extensionslib/src/main/java/com/omega_r/libs/extensions/coroutines/CoroutinesExtensions.kt

@@ -11,30 +11,46 @@ import kotlin.time.toDuration
 
 fun CoroutineScope.launchWithTicker(
     ticksCount: Int,
-    durationUnit: DurationUnit,
+    tickDurationMillis: Long,
     onTick: suspend (Int) -> Unit,
     onEnd: (suspend () -> Unit)? = null,
     initialDelayMillis: Long = 0,
 ): ReceiveChannel<Unit> {
     val tickerChannel = ticker(
-        ticksCount.toDuration(durationUnit).toLongMilliseconds(),
+        tickDurationMillis,
         initialDelayMillis
     )
     launch {
         var currentTick = 0
         for (event in tickerChannel) {
-            if (currentTick >= ticksCount) {
+            onTick(currentTick)
+            if (currentTick == ticksCount) {
                 onEnd?.invoke()
                 tickerChannel.cancel()
                 break
             }
-            onTick(currentTick)
             currentTick++
         }
     }
     return tickerChannel
 }
 
+fun CoroutineScope.launchWithTicker(
+    ticksCount: Int,
+    tickDuration: Duration,
+    onTick: suspend (Int) -> Unit,
+    onEnd: (suspend () -> Unit)? = null,
+    initialDelay: Duration = Duration.ZERO,
+): ReceiveChannel<Unit> {
+    return launchWithTicker(
+        ticksCount = ticksCount,
+        tickDurationMillis = tickDuration.toLongMilliseconds(),
+        onTick = onTick,
+        onEnd = onEnd,
+        initialDelayMillis = initialDelay.toLongMilliseconds()
+    )
+}
+
 fun CoroutineScope.launchDelayed(delayMillis: Long, action: suspend () -> Unit) {
     launch {
         delay(delayMillis)