move from logging → event listener

app/src/main/java/com/instacart/library/sample/SampleActivity.kt

@@ -62,7 +62,7 @@ class SampleActivity : AppCompatActivity() {
         val mainDispatcherScope = CoroutineScope(Dispatchers.Main.immediate)
 
         if (!::trueTime.isInitialized) {
-            trueTime = TrueTimeImpl(logger = AndroidLogger)
+            trueTime = TrueTimeImpl()
         }
 
         val with = TrueTimeParameters(

library/src/main/java/com/instacart/truetime/TrueTimeEventListener.kt

@@ -0,0 +1,94 @@
+package com.instacart.truetime
+
+import com.instacart.truetime.time.TrueTimeParameters
+import java.util.*
+
+interface TrueTimeEventListener : SntpEventListener, TimeKeeperListener {
+
+    /**
+     * TrueTime initialize call performed
+     */
+    fun initialize(with: TrueTimeParameters)
+
+    /**
+     * TrueTime came back with [ntpResult]
+     */
+    fun initializeSuccess(ntpResult: LongArray)
+
+    /**
+     * Main TrueTime initialization call failed
+     * with a generic exception [e]
+     */
+    fun initializeFailed(e: Exception)
+
+    /**
+     * The next TrueTime initialization call
+     * will be attempted in [delay]
+     */
+    fun nextInitializeIn(delay: Long)
+
+    /**
+     * Resolved NTP pool host address [ntpHost]
+     * to the list of IP addresses [ipList]
+     */
+    fun resolvedNtpHostToIPs(ntpHost: String, ipList: List<String>)
+
+    fun sntpRequestLastAttempt(ipHost: String)
+
+    /**
+     * SNTP request failed with exception [e]
+     */
+    fun sntpRequestFailed(e: Exception)
+}
+
+interface SntpEventListener {
+
+    /**
+     * requesting time from [ntpHost] which should be an IP address
+     */
+    fun requestingTime(ntpHost: String)
+
+    /**
+     * Invoked after the SNTP request to [ntpHost] comes back successful
+     */
+    fun responseSuccessful(ntpHost: String)
+
+    /**
+     * Invoked if the SNTP request to [ntpHost] fails for any reason
+     */
+    fun responseFailed(ntpHost: String, e: Exception)
+}
+
+interface TimeKeeperListener {
+  fun storingTrueTime(ntpResult: LongArray)
+
+  /**
+   * TimeKeeper has the "true" time
+   * and is returning it
+   */
+  fun returningTrueTime(trueTime: Date)
+
+  /**
+   * TimeKeeper does not have the "true" time
+   * returning device time.
+   */
+  fun returningDeviceTime()
+}
+
+object NoOpEventListener : TrueTimeEventListener {
+  override fun initialize(with: TrueTimeParameters) {}
+  override fun initializeSuccess(ntpResult: LongArray) {}
+  override fun initializeFailed(e: Exception) {}
+  override fun nextInitializeIn(delay: Long) {}
+  override fun resolvedNtpHostToIPs(ntpHost: String, ipList: List<String>) {}
+  override fun sntpRequestLastAttempt(ipHost: String) {}
+  override fun sntpRequestFailed(e: Exception) {}
+
+  override fun requestingTime(ntpHost: String) {}
+  override fun responseSuccessful(ntpHost: String) {}
+  override fun responseFailed(ntpHost: String, e: Exception) {}
+
+  override fun storingTrueTime(ntpResult: LongArray) {}
+  override fun returningTrueTime(trueTime: Date) {}
+  override fun returningDeviceTime() {}
+}

library/src/main/java/com/instacart/truetime/sntp/Sntp.kt

@@ -1,5 +1,6 @@
 package com.instacart.truetime.sntp
 
+import com.instacart.truetime.SntpEventListener
 import java.io.IOException
 import java.lang.Exception
 
@@ -34,12 +35,12 @@ interface Sntp {
      */
     @Throws(IOException::class)
     fun requestTime(
-        ntpHostAddress: String,
-        rootDelayMax: Float,
-        rootDispersionMax: Float,
-        serverResponseDelayMax: Int,
-        timeoutInMillis: Int,
-        listener: SntpEventListener,
+      ntpHostAddress: String,
+      rootDelayMax: Float,
+      rootDispersionMax: Float,
+      serverResponseDelayMax: Int,
+      timeoutInMillis: Int,
+      listener: SntpEventListener,
     ): LongArray
 
 }

library/src/main/java/com/instacart/truetime/sntp/SntpImpl.java

@@ -24,6 +24,8 @@
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
+
+import com.instacart.truetime.SntpEventListener;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -100,6 +102,8 @@ public synchronized long[] requestTime(
       SntpEventListener listener
   ) throws IOException {
 
+    listener.requestingTime(ntpHost);
+
     DatagramSocket socket = null;
 
     try {

library/src/main/java/com/instacart/truetime/time/TimeKeeper.kt

@@ -1,6 +1,7 @@
 package com.instacart.truetime.time
 
 import android.os.SystemClock
+import com.instacart.truetime.TimeKeeperListener
 import com.instacart.truetime.sntp.Sntp
 import java.util.Date
 import java.util.concurrent.atomic.AtomicReference
@@ -12,20 +13,26 @@ import java.util.concurrent.atomic.AtomicReference
  * and derives true time from that result
  */
 internal class TimeKeeper(
-    private val sntp: Sntp
+  private val sntp: Sntp,
+  private val listener: TimeKeeperListener,
 ) {
     private var ttResult: AtomicReference<LongArray> = AtomicReference()
 
     fun hasTheTime(): Boolean = ttResult.get() != null
 
-    fun save(ntpResult: LongArray) = ttResult.set(ntpResult)
+    fun save(ntpResult: LongArray) {
+        listener.storingTrueTime(ntpResult)
+        ttResult.set(ntpResult)
+    }
 
     fun now(): Date {
         val ntpResult = ttResult.get()
         val savedSntpTime: Long = sntp.trueTime(ntpResult)
         val timeSinceBoot: Long = sntp.timeSinceBoot(ntpResult)
         val currentTimeSinceBoot: Long = SystemClock.elapsedRealtime()
+        val trueTime = Date(savedSntpTime + (currentTimeSinceBoot - timeSinceBoot))
 
-        return Date(savedSntpTime + (currentTimeSinceBoot - timeSinceBoot))
+        listener.returningTrueTime(trueTime)
+        return trueTime
     }
 }

library/src/main/java/com/instacart/truetime/time/TrueTimeImpl.kt

@@ -1,11 +1,8 @@
 package com.instacart.truetime.time
 
-import com.instacart.truetime.EventListener
+import com.instacart.truetime.TrueTimeEventListener
 import com.instacart.truetime.NoOpEventListener
-import com.instacart.truetime.log.Logger
-import com.instacart.truetime.log.LoggerNoOp
 import com.instacart.truetime.sntp.Sntp
-import com.instacart.truetime.sntp.SntpEventListener
 import com.instacart.truetime.sntp.SntpImpl
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -17,16 +14,11 @@ import java.net.UnknownHostException
 import java.util.Date
 
 class TrueTimeImpl(
-    private val eventListener: EventListener = NoOpEventListener,
-    private val logger: Logger = LoggerNoOp,
+    private val listener: TrueTimeEventListener = NoOpEventListener,
 ) : TrueTime {
 
     private val sntp: Sntp = SntpImpl()
-    private val timeKeeper = TimeKeeper(sntp)
-
-    companion object {
-        private const val TAG: String = "TrueTimeImpl"
-    }
+    private val timeKeeper = TimeKeeper(sntp, listener)
 
     override fun initialized(): Boolean = timeKeeper.hasTheTime()
 
@@ -36,55 +28,50 @@ class TrueTimeImpl(
                 try {
                     initialize(with)
                 } catch (e: Exception) {
-                    logger.e(TAG, "- TrueTime initialization failed", e)
+                    listener.initializeFailed(e)
                 }
-                delay(with.syncIntervalInMillis)
-                logger.v(TAG, "- starting next resync")
+
+              listener.nextInitializeIn(with.syncIntervalInMillis)
+              delay(with.syncIntervalInMillis)
             }
         }
     }
 
     override fun initialize(with: TrueTimeParameters): Date {
-        logger.v(TAG, "- initializing TrueTime")
         val ntpResult = init(with)
-        logger.v(TAG, "- saving TrueTime NTP result")
         timeKeeper.save(ntpResult = ntpResult)
-        logger.v(TAG, "- returning Time now")
         return timeKeeper.now()
     }
 
     override fun nowSafely(): Date {
         return if (timeKeeper.hasTheTime()) {
-            logger.v(TAG, "TimeKeeper has the time")
             nowTrueOnly()
         } else {
-            logger.d(TAG, "TimeKeeper does NOT have time: returning device time safely")
+            listener.returningDeviceTime()
             Date()
         }
     }
 
     override fun nowTrueOnly(): Date {
         if (!initialized()) throw IllegalStateException("TrueTime was not initialized successfully yet")
-        logger.v(TAG, "returning Time now")
         return timeKeeper.now()
     }
 
-
     //region private helpers
 
     /**
      * Initialize TrueTime with an ntp pool server address
      */
     private fun init(with: TrueTimeParameters): LongArray {
+        listener.initialize(with)
 
         // resolve NTP pool -> single IPs
-        return resolveNtpHostToIPs(with.ntpHostPool.first())
+        val ntpResult = resolveNtpHostToIPs(with.ntpHostPool.first())
             // for each IP resolved
             .map { ipHost ->
-                logger.v(TAG, "---- requesting time (single IP: $ipHost)")
                 // 5 times against each IP
                 (1..5)
-                    .map { requestTime(with, ipHost, eventListener) }
+                    .map { requestTime(with, ipHost) }
                     // collect the 5 results to list
                     .toList()
                     // filter least round trip delay to get single Result
@@ -94,49 +81,50 @@ class TrueTimeImpl(
             .take(5)
             // filter median clock offset to get single Result
             .filterMedianClockOffset()
+
+        listener.initializeSuccess(ntpResult)
+        return ntpResult
     }
 
     /**
      * resolve ntp host pool address to single IPs
      */
     @Throws(UnknownHostException::class)
-    private fun resolveNtpHostToIPs(ntpHost: String): List<String> {
-        logger.v(TAG, "-- resolving ntpHost : $ntpHost")
-        return InetAddress.getAllByName(ntpHost).map { it.hostAddress }
+    private fun resolveNtpHostToIPs(ntpHostAddress: String): List<String> {
+        val ipList = InetAddress.getAllByName(ntpHostAddress).map { it.hostAddress }
+        listener.resolvedNtpHostToIPs(ntpHostAddress, ipList)
+        return ipList
     }
 
     private fun requestTime(
       with: TrueTimeParameters,
       ipHostAddress: String,
-      eventListener: EventListener,
     ): LongArray {
         // retrying upto (default 50) times if necessary
         repeat(with.retryCountAgainstSingleIp - 1) {
             try {
                 // request Time
-                logger.v(TAG, "------ requesting SNTP time")
-                return sntpRequest(with, ipHostAddress, eventListener)
+                return sntpRequest(with, ipHostAddress)
             } catch (e: Exception) {
-                logger.e(TAG, "------ Error requesting SNTP time", e)
+                listener.sntpRequestFailed(e)
             }
         }
 
         // last attempt
-        logger.i(TAG, "---- last attempt for $ipHostAddress")
+        listener.sntpRequestLastAttempt(ipHostAddress)
         return sntpRequest(with, ipHostAddress)
     }
 
     private fun sntpRequest(
-        with: TrueTimeParameters,
-        ipHostAddress: String,
-        eventListener: EventListener,
+      with: TrueTimeParameters,
+      ipHostAddress: String,
     ): LongArray = sntp.requestTime(
         ntpHostAddress = ipHostAddress,
         rootDelayMax = with.rootDelayMax,
         rootDispersionMax = with.rootDispersionMax,
         serverResponseDelayMax = with.serverResponseDelayMax,
         timeoutInMillis = with.connectionTimeoutInMillis,
-        listener = eventListener as SntpEventListener
+        listener = listener,
     )
 
     private fun List<LongArray>.filterLeastRoundTripDelay(): LongArray {