Dispatch periodic sync

library/src/commonMain/kotlin/com/tidal/networktime/internal/OperationCoordinator.kt

@@ -4,22 +4,24 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import kotlin.time.Duration
 
 internal class OperationCoordinator
 @OptIn(ExperimentalCoroutinesApi::class)
 constructor(
   private val mutableState: MutableState,
   private val coroutineScope: CoroutineScope,
   globalDispatcher: CoroutineDispatcher,
-  private val privateDispatcher: CoroutineDispatcher = globalDispatcher.limitedParallelism(1),
+  private val syncInterval: Duration,
+  private val toggleDispatcher: CoroutineDispatcher = globalDispatcher.limitedParallelism(1),
+  private val syncDispatcher: CoroutineDispatcher = globalDispatcher.limitedParallelism(1),
 ) {
 
-  fun dispatchStartSync() = dispatch(StartSyncRunnable(mutableState))
+  fun dispatchStartSync() = dispatch(
+    SyncEnable(mutableState, coroutineScope, syncDispatcher, syncInterval),
+  )
 
-  fun dispatchStopSync() = dispatch(StopSyncRunnable(mutableState))
+  fun dispatchStopSync() = dispatch(SyncDisable(mutableState))
 
-  private fun dispatch(block: () -> Unit) = coroutineScope.launch {
-    withContext(privateDispatcher) { block() }
-  }
+  private fun dispatch(block: () -> Unit) = coroutineScope.launch(toggleDispatcher) { block() }
 }

library/src/commonMain/kotlin/com/tidal/networktime/internal/PlatformAgnosticSNTPClient.kt

@@ -10,13 +10,13 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
 internal class PlatformAgnosticSNTPClient(
-  val ntpServers: Array<out NTPServer>,
-  val referenceClock: ReadableClock,
-  val coroutineScope: CoroutineScope,
-  val synchronizationInterval: Duration = 64.seconds,
+  private val ntpServers: Array<out NTPServer>,
+  private val referenceClock: ReadableClock,
+  private val coroutineScope: CoroutineScope,
+  private val syncInterval: Duration = 64.seconds,
   private val httpClient: HttpClient = HttpClientFactory()(),
   private val operationCoordinator: OperationCoordinator =
-    OperationCoordinator(MutableState(), coroutineScope, Dispatchers.IO),
+    OperationCoordinator(MutableState(), coroutineScope, Dispatchers.IO, syncInterval),
 ) {
   val synchronizedEpochTime: Duration?
     get() = TODO("Get the time")

library/src/commonMain/kotlin/com/tidal/networktime/internal/StopSyncRunnable.kt → library/src/commonMain/kotlin/com/tidal/networktime/internal/SyncDisable.kt

@@ -1,6 +1,6 @@
 package com.tidal.networktime.internal
 
-internal class StopSyncRunnable(private val mutableState: MutableState) : () -> Unit {
+internal class SyncDisable(private val mutableState: MutableState) : () -> Unit {
   override operator fun invoke() = with(mutableState) {
     val job = job ?: return
     if (!job.isCancelled) {

library/src/commonMain/kotlin/com/tidal/networktime/internal/SyncEnable.kt

@@ -0,0 +1,21 @@
+package com.tidal.networktime.internal
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlin.time.Duration
+
+internal class SyncEnable(
+  private val mutableState: MutableState,
+  private val coroutineScope: CoroutineScope,
+  private val syncDispatcher: CoroutineDispatcher,
+  private val syncInterval: Duration,
+) : () -> Unit {
+  override operator fun invoke() = with(mutableState) {
+    val job = job
+    if (job != null && !job.isCancelled) {
+      return
+    }
+    this.job = coroutineScope.launch(syncDispatcher) { SyncPeriodic(syncInterval)() }
+  }
+}

library/src/commonMain/kotlin/com/tidal/networktime/internal/SyncPeriodic.kt

@@ -0,0 +1,13 @@
+package com.tidal.networktime.internal
+
+import kotlinx.coroutines.delay
+import kotlin.time.Duration
+
+internal class SyncPeriodic(private val syncInterval: Duration) {
+  suspend operator fun invoke() {
+    while (true) {
+      SyncSingular()()
+      delay(syncInterval)
+    }
+  }
+}

library/src/commonMain/kotlin/com/tidal/networktime/internal/SyncSingular.kt

@@ -0,0 +1,7 @@
+package com.tidal.networktime.internal
+
+internal class SyncSingular {
+  suspend operator fun invoke() {
+    TODO()
+  }
+}