Android Dev Summit 2025 in Mountain View addressed a common pain point in Android development: UUID v4 primary keys in Room produce random insertion order that prevents efficient time-ordered queries. UUID v7 fixes this — millisecond-precision timestamps in the ID prefix give chronological order with no extra columns. See UUID in Kotlin for the broader Kotlin context.
Event details
| Conference | Android Dev Summit 2025 |
| Date | November 6–7, 2025 |
| Location | Mountain View, CA, USA |
| Focus | UUID v7 in Android apps — Room, WorkManager, Kotlin coroutines |
Key sessions
UUID v7 in Room database entities
// build.gradle.kts
implementation("com.github.f4b6a3:uuid-creator:5.3.7")
// OrderEntity.kt
import androidx.room.Entity
import androidx.room.PrimaryKey
import com.github.f4b6a3.uuid.UuidCreator
@Entity(tableName = "orders")
data class OrderEntity(
@PrimaryKey
val id: String = UuidCreator.getTimeOrderedEpoch().toString(),
val customerId: String,
val total: Double,
val status: String = "pending",
)
// OrderDao.kt
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
@Dao
interface OrderDao {
@Insert
suspend fun insert(order: OrderEntity)
// UUID v7 lexicographic ORDER BY = chronological order
@Query("SELECT * FROM orders ORDER BY id ASC")
suspend fun getAllChronological(): List<OrderEntity>
// Cursor pagination with UUID v7
@Query("SELECT * FROM orders WHERE id > :cursor ORDER BY id ASC LIMIT :limit")
suspend fun getPage(cursor: String, limit: Int): List<OrderEntity>
}
WorkManager job IDs with UUID v7
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager
import com.github.f4b6a3.uuid.UuidCreator
import java.util.UUID
class OrderSyncWorker(context: Context, workerParams: WorkerParameters) :
CoroutineWorker(context, workerParams) {
override suspend fun doWork(): Result {
val jobId = id.toString() // UUID v7 — this is the WorkManager job ID
Log.d("OrderSync", "Starting job $jobId")
// jobId encodes when the job was enqueued — useful for log correlation
return Result.success()
}
}
// Enqueue with UUID v7 job ID
fun enqueueOrderSync(workManager: WorkManager) {
val jobId = UUID.fromString(UuidCreator.getTimeOrderedEpoch().toString())
val request = OneTimeWorkRequest.Builder(OrderSyncWorker::class.java)
.setId(jobId)
.build()
workManager.enqueue(request)
}
See UUID in Kotlin for the full Kotlin UUID guide.
Coroutine-safe UUID v7 generation
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import com.github.f4b6a3.uuid.UuidCreator
// Repository layer: generate and insert
class OrderRepository(private val dao: OrderDao) {
suspend fun createOrder(customerId: String, total: Double): OrderEntity {
val order = withContext(Dispatchers.Default) {
OrderEntity(
id = UuidCreator.getTimeOrderedEpoch().toString(),
customerId = customerId,
total = total,
)
}
dao.insert(order)
return order
}
suspend fun listOrdersPage(cursor: String? = null, limit: Int = 20): Pair<List<OrderEntity>, String?> {
val rows = if (cursor != null) {
dao.getPage(cursor, limit)
} else {
dao.getPage("", limit)
}
val nextCursor = if (rows.size == limit) rows.last().id else null
return Pair(rows, nextCursor)
}
}
UUID v7 in ViewModel and Hilt
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class OrderViewModel @Inject constructor(
private val repository: OrderRepository
) : ViewModel() {
private val _orders = MutableStateFlow<List<OrderEntity>>(emptyList())
val orders: StateFlow<List<OrderEntity>> = _orders
fun loadOrders() {
viewModelScope.launch {
val (rows, _) = repository.listOrdersPage()
_orders.value = rows
}
}
fun createOrder(customerId: String, total: Double) {
viewModelScope.launch {
repository.createOrder(customerId, total)
loadOrders()
}
}
}
Extracting timestamp from UUID v7 on Android
import com.github.f4b6a3.uuid.UuidCreator
import com.github.f4b6a3.uuid.codec.other.TimeOrderedCodec
import java.time.Instant
// Extract when an order was created from its UUID v7 ID
fun extractCreatedAt(orderId: String): Instant {
val uuid = java.util.UUID.fromString(orderId)
// Top 48 bits = Unix milliseconds
val msb = uuid.mostSignificantBits
val timestampMs = msb ushr 16 // shift right 16 bits to get the 48-bit ms timestamp
return Instant.ofEpochMilli(timestampMs)
}
See UUID Bit Fields for the 48-bit timestamp layout.
Conference takeaways
- uuid-creator is the best UUID v7 library for Android — pure Java, no Android-specific dependencies
- Room + UUID v7 — use
Stringprimary keys,ORDER BY idreplacesORDER BY created_at - WorkManager —
java.util.UUID.fromString()accepts UUID v7 strings directly - Avoid UUID v7 on the main thread — use
Dispatchers.Defaultfor batch generation - UUID v7 strings in SharedPreferences — save as string, parse on read; no serialization overhead
Further reading
- UUID in Kotlin — v4 and v7 on the JVM and Android
- UUID v7 in Kotlin Multiplatform — KMP Guide
- UUID in Mobile Apps — iOS and Android Patterns
- UUID v7 in Microservices — Trace IDs and Correlation
- Devoxx Belgium 2025 — UUID v7 on the JVM
External references
Frequently asked questions
How do I use UUID v7 in Android Room database?
Define your Room entity with a String primary key and generate UUID v7 in the data layer before insertion. Use the uuid-creator library for UUID v7 on Android: UuidCreator.getTimeOrderedEpoch().toString(). UUID v7 strings sort lexicographically in chronological order, so ORDER BY id ASC in a Room query gives insertion order without a createdAt column.
Can I use UUID v7 as a WorkManager job ID?
Yes. WorkManager accepts custom OneTimeWorkRequest IDs via OneTimeWorkRequest.Builder(MyWorker::class.java).setId(UUID.fromString(uuidV7)).build(). UUID v7's timestamp prefix means WorkManager job IDs reflect when the job was enqueued — useful for debugging and correlating job logs. Note: java.util.UUID.fromString() accepts UUID v7 strings without any changes.
Is UUID v7 safe to generate in Kotlin coroutines on Android?
Yes. UUID v7 generation is CPU-only with no I/O. Call UuidCreator.getTimeOrderedEpoch() from any dispatcher — Dispatchers.IO, Dispatchers.Default, or Dispatchers.Main. For batch inserts on background threads, generate IDs in withContext(Dispatchers.Default) to avoid blocking the main thread.