update readme & deps, fix lib & sample

Author: softartdev

README.MD

@@ -1,24 +1,56 @@
 # Kronos Multiplatform Library
+Development in progress 🛠
 
-Development in progress
+Kotlin Multiplatform library for time synchronization. 
+Extension for [kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime) library.
+Supported platforms:
+- Android
+- iOS
+- Desktop JVM (MacOS, Linux, Windows)
+## Usage
+### [kotlinx-datetime](https://github.com/Kotlin/kotlinx-datetime) extension
+Use `Clock.Network.now()` to get the current network time. 
+This can be used in conjunction with the built-in `Clock.System.now()` method.
+```kotlin
+val networkTime: Instant = Clock.Network.now()
+val systemTime: Instant = Clock.System.now()
+val diff: Duration = networkTime - systemTime
+```
+### Synchronization
+When running the application, it is necessary to synchronize the time with the network using the platform code function:
+```kotlin
+Clock.Network.sync()
+```
+For example, on Android:
+```kotlin
+class App : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        Clock.Network.sync(applicationContext)
+    }
+}
+```
+### Installation
+The latest release is available on [Maven Central](https://repo1.maven.org/maven2/io/github/softartdev/kronos/).
+1. Add the Maven Central repository if it is not already there:
+```kotlin
+repositories {
+    mavenCentral()
+}
+```
+2. In multiplatform projects, add a dependency to the commonMain source set dependencies
+```kotlin
+commonMain {
+    dependencies {
+        implementation("io.github.softartdev:kronos:$latestVersion")
+    }
+}
+```
+## Implementation
+Main common interface implemented with using:
+- [lyft/Kronos](https://github.com/lyft/Kronos-Android) for Java & Android
+- [MobileNativeFoundation/Kronos](https://github.com/MobileNativeFoundation/Kronos) for iOS
 
-## Before running!
- - check your system with (KDoctor)[https://github.com/Kotlin/kdoctor]
- - add `local.properties` file to the project root and set a path to Android SDK there
- - run `./gradlew podInstall` in the project root
-
-### Android
-To run the application on android device/emulator:  
- - open project in Android Studio and run imported android run configuration
-
-To build the application bundle:
- - run `./gradlew :composeApp:assembleDebug`
- - find `.apk` file in `composeApp/build/outputs/apk/debug/composeApp-debug.apk`
-
-### Desktop
-Run the desktop application: `./gradlew :composeApp:run`
-
-### iOS
-To run the application on iPhone device/simulator:
- - Open `iosApp/iosApp.xcworkspace` in Xcode and run standard configuration
- - Or use (Kotlin Multiplatform Mobile plugin)[https://plugins.jetbrains.com/plugin/14936-kotlin-multiplatform-mobile] for Android Studio
+The project is assembled and checked thanks to:
+- [Swift Klib Gradle Plugin](https://github.com/ttypic/swift-klib-plugin) including Swift source files in KMM shared module
+- [Compose Multiplatform, by JetBrains](https://github.com/JetBrains/compose-jb) for UI samples

gradle/libs.versions.toml

@@ -3,7 +3,7 @@
 lyft-kronos = "0.0.1-alpha11"
 kotlin = "1.8.20"
 agp = "7.4.2"
-compose = "1.4.0-rc03"
+compose = "1.4.0"
 androidx-appcompat = "1.6.1"
 androidx-activityCompose = "1.7.0"
 androidx-test = "1.5.0"

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

kronos/src/commonMain/kotlin/com/softartdev/kronos/NetworkClock.kt

@@ -12,5 +12,9 @@ interface NetworkClock : Clock {
     /**
      * Returns the [Instant] corresponding to the current time, according to this clock.
      */
-    override fun now(): Instant = getCurrentNtpTimeMs()!!.let(Instant::fromEpochMilliseconds)
+    override fun now(): Instant {
+        val currentNtpTimeMs = getCurrentNtpTimeMs()
+        requireNotNull(currentNtpTimeMs) { "No ntp sync has occurred" }
+        return Instant.fromEpochMilliseconds(currentNtpTimeMs)
+    }
 }

kronos/src/iosMain/kotlin/com/softartdev/kronos/IosNetworkClock.kt

@@ -23,7 +23,7 @@ object IosNetworkClock : NetworkClock {
     }
 
     override fun getCurrentNtpTimeMs(): Long? {
-        val nsDate: NSDate? = Kronos.now()
-        return nsDate?.timeIntervalSince1970?.toLong()
+        val nsDate: NSDate = Kronos.now() ?: return null
+        return nsDate.timeIntervalSince1970.toLong() * 1000
     }
 }

kronos/src/iosTest/kotlin/com/softartdev/kronos/PlatformTest.kt

@@ -19,4 +19,18 @@ class PlatformTest {
         }
         assertNotNull(Clock.Network.getCurrentNtpTimeMs())
     }
+
+    @Ignore
+    @Test
+    fun awaitSyncTest() = runTest {
+        val currentNtpTimeMs = Clock.Network.getCurrentNtpTimeMs()
+        println("⏺️ before sync: $currentNtpTimeMs")
+        assertNull(currentNtpTimeMs)
+
+        Clock.Network.awaitSync()
+
+        val instance = Clock.Network.now()
+        println("⏺️ after sync: $instance")
+        assertNotNull(instance)
+    }
 }

sampleApp/src/commonMain/kotlin/com/softartdev/kronos/sample/App.kt

@@ -13,20 +13,21 @@ import com.softartdev.kronos.Network
 import io.github.aakira.napier.Napier
 import kotlinx.coroutines.launch
 import kotlinx.datetime.Clock
+import kotlin.time.Duration
 
 @Composable
 internal fun App() = AppTheme {
-    var ntpTimeMs by remember { mutableStateOf(Clock.Network.getCurrentNtpTimeMs()) }
+    var diffDuration by remember { mutableStateOf(calcDiffDuration()) }
     val loadingState: MutableState<Boolean> = remember { mutableStateOf(false) }
     val coroutineScope = rememberCoroutineScope()
     Column(
         modifier = Modifier.fillMaxSize(),
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.SpaceEvenly
     ) {
-        Text(text = "Network time millis: $ntpTimeMs")
-        Button(onClick = { ntpTimeMs = logNtpTimeMs() }) {
-            Text(text = "Refresh network time millis")
+        Text(text = "Difference duration between system and network time:\n$diffDuration")
+        Button(onClick = { diffDuration = calcDiffDuration() }) {
+            Text(text = "Refresh difference duration")
         }
         Button(onClick = ::clickSync) {
             Text(text = "Sync network time async")
@@ -59,12 +60,12 @@ internal expect fun clickBlockingSync()
 
 internal expect suspend fun clickAwaitSync()
 
-private fun logNtpTimeMs(): Long? {
-    val networkTimeMs = Clock.Network.getCurrentNtpTimeMs()
-    Napier.d(tag = "⌚️", message = "Network time millis: $networkTimeMs")
-    val systemTimeMs = Clock.System.now().toEpochMilliseconds()
-    Napier.d(tag = "⌚️", message = "System time millis: $systemTimeMs")
-    val diff = networkTimeMs?.minus(systemTimeMs)
+private fun calcDiffDuration(): Duration {
+    val sysInstant = Clock.System.now()
+    Napier.d(tag = "⌚️", message = "System time: $sysInstant")
+    val netInstant = Clock.Network.now()
+    Napier.d(tag = "⌚️", message = "Network time: $netInstant")
+    val diff: Duration = netInstant - sysInstant
     Napier.d(tag = "⌚️", message = "Diff: $diff")
-    return networkTimeMs
+    return diff
 }