## 1. Overview

Converting milliseconds to minutes and seconds can be very useful while dealing with time-related calculations in a Kotlin application. Furthermore, it can help improve the readability of time-related data by making them more user-friendly to interpret.

In this tutorial, we’ll learn multiple ways to convert milliseconds to minutes and seconds.

## 2. Using Arithmetic Operations

First, let’s initialize the millis variable with a sample value denoting milliseconds:

``val millis:Long = 123456L``

Now, we can apply the division operator to convert milliseconds to minutes:

``val mins = millis / 60000``

It’s important to note that Kotlin truncates the decimal portion when we divide between Int and Long values. So, mins will contain the whole number of minutes.

Next, we can calculate the remaining seconds value from millisÂ using modulus (%) and division (/) operators:

``val secs = (millis % 60000) / 1000``

Finally, let’s validate that we’ve got the correct values in mins and secs variables:

``````assertEquals(2, mins)
assertEquals(3, secs)``````

The output looks correct.

## 3. Using kotlin.time From the Standard Library

In this section, we’ll use the kotlin.time package from the Kotlin standard library for solving our use case of converting milliseconds to minutes and seconds.

### 3.1. Using Duration and DurationUnit Classes

Let’s start by creating a duration object from millis using the toDuration() function:

``val duration = millis.toDuration(DurationUnit.MILLISECONDS)``

We must note that we passed DurationUnit.MILLISECONDS to specify that we’re measuring millis in milliseconds.

Further, we can get the minutes using the inWholeMinutes property of the duration object:

``val mins = duration.inWholeMinutes``

Furthermore, we can calculate the remaining duration using the minus() method and get the remaining seconds from the inWholeSecondsÂ property:

``val secs = duration.minus(mins.toDuration(DurationUnit.MINUTES)).inWholeSeconds``

Lastly, let’s verify that our approach is giving the right results:

``````assertEquals(2, mins)
assertEquals(3, secs)``````

Fantastic! It looks correct.

### 3.2. Using Extension Properties from Duration.Companion

Alternatively, we can use the extension properties from Duration.Companion to create duration objects conveniently.

First, to get the minutes, we can create a Duration object using millis.milliseconds and then retrieve the inWholeMinutes property:

``val mins = millis.milliseconds.inWholeMinutes``

Next, we can get the remaining seconds by subtracting the inWholeSeconds property value of theÂ mins.minutes duration from that of millis.milliseconds:

``val secs = millis.milliseconds.inWholeSeconds - mins.minutes.inWholeSeconds``

Finally, let’s verify the result:

``````assertEquals(2, mins)
assertEquals(3, secs)``````

Perfect! It works as expected.

## 4. Using kotlinx-datetime Library

The kotlinx-datetime library is part of the Kotlin ecosystem and provides convenient APIs for working with date and time operations. In this section, we’ll use it to retrieve the minutes and seconds from the epoch milliseconds.

### 4.1. Maven Dependency

To use the kotlinx-datetime library, we must add the dependency for kotlinx-datetime-jvmÂ in the project’s pom.xml:

``````<dependency>
<groupId>org.jetbrains.kotlinx</groupId>
<artifactId>kotlinx-datetime-jvm</artifactId>
<version>0.4.0</version>
</dependency>``````

It’s now available for use.

### 4.2. Minutes and Seconds From Epoch Milliseconds

First, let’s set epochMillisÂ with the epoch value:

``val epochMillis: Long = 123456L``

It’s important to note that this epoch value represents the “Thu Jan 01 1970 00:02:03” timestamp in UTC.

Now, let’s create an instant object using the fromEpochMilliseconds() method of the Instant class:

``val instant = Instant.fromEpochMilliseconds(epochMillis)``

The instant object represents an absolute timestamp in UTC (Coordinated Universal Time).

Further, we can obtain an equivalent localDateTime object using the TimeZone.UTC timezone and our instant object:

``val localDateTime = instant.toLocalDateTime(TimeZone.UTC)``

Next, we can use the hour, minute, and second properties of the localDateTime object to calculate the minutes and seconds:

``````val mins = localDateTime.hour * 60 + localDateTime.minute.toLong()
val secs = localDateTime.second.toLong()``````

We must note that the resultant values represent minutes and seconds elapsed on a specific day by the UTC clock.

Finally, let’s validate the results:

``````assertEquals(2, mins)
assertEquals(3, secs)``````

Great! We got this one right.

## 5. Conclusion

In this article, we started with an approach of using arithmetic operations to convert the minutes and seconds from milliseconds. Furthermore, we explored time-based APIs from the kotlin.time and kotlinx.datetime packages available in Kotlin standard and kotlinx-datetime libraries, respectively.