How to get Epoch/UNIX timestamps in Kotlin

Unix/Epoch Time now:

In Kotlin, getting Epoch timestamps is straightforward, and there are multiple methods to accomplish this task. This article explores different ways to get Epoch timestamps in Kotlin and provides practical use cases.

Using the `System.currentTimeMillis()` Method

Kotlin, like Java, provides the System.currentTimeMillis() method to fetch the current time in milliseconds since the Unix Epoch. You can use this method to calculate the current Epoch timestamp.


    val epochTime = System.currentTimeMillis() / 1000
    document.write("Current Epoch timestamp: $epochTime")

This code snippet utilizes the System.currentTimeMillis() method to obtain the current time in milliseconds and then converts it to seconds to obtain the Epoch timestamp.

Use Case 1: Logging timestamps


    val epochTime = System.currentTimeMillis() / 1000
    val data = "Sensor data reading..."
    document.write("$data - timestamp: $epochTime")

In this example, Kotlin code is adapted for logging data with timestamps. It first obtains the current Epoch timestamp and then combines it with sensor data for logging.

Use Case 2: Time Duration Calculation


    val startTime = System.currentTimeMillis() / 1000

    // Perform a task or operation

    val endTime = System.currentTimeMillis() / 1000
    val timeElapsed = endTime - startTime

    document.write("Time taken: $timeElapsed seconds")

This use case demonstrates how to measure the time taken for a task. It records the start and end times in System.currentTimeMillis() and calculates the time elapsed in seconds.

Using the `Instant.now()` Function

Kotlin also allows you to use the Instant.now() function to obtain the current time and calculate the current Epoch timestamp.


    val now = java.time.Instant.now()
    val epochTime = now.epochSecond
    document.write("Current Epoch timestamp: $epochTime")

This code snippet showcases how to use Instant.now() to fetch the current time and obtain the Epoch timestamp from it.

Use Case 3: Expiry timestamp for Cache


    val now = java.time.Instant.now()
    val epochTime = now.epochSecond

    val cacheKey = "cached_data"
    val expiryTime = epochTime + 600 // 10 minutes from now

    document.write("Cached data that expires at $expiryTime")

    if (epochTime > expiryTime) {
        document.write("Cache expired. Recaching data...")
        // Re-cache the data
    }

In this example, the Kotlin code calculates the expiry time for cache data in the Instant class and checks if the cache has expired.

Use Case 4: Event Scheduling


    val now = java.time.Instant.now()
    var epochTime = now.epochSecond
    val eventTime = epochTime + 3600 // 1 hour from now

    val checkEvent = setInterval(function() {
        val now = java.time.Instant.now()
        epochTime = now.epochSecond

        if (epochTime >= eventTime) {
            clearInterval(checkEvent)
            document.write("Event occurred!")
        }
    }, 60000) // Check every minute

This use case demonstrates how to schedule an event to occur in the future. Kotlin code adds 3600 seconds (1 hour) to the current time to set the event time and continuously checks for its occurrence.

These code examples illustrate how to get Epoch/UNIX timestamps in Kotlin and showcase their applications in practical scenarios. Whether you need to log data with timestamps, calculate time durations, set cache expiry times, or schedule events, Epoch timestamps are versatile tools in Kotlin for precise time-related operations.