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

ConferenceAndroid Dev Summit 2025
DateNovember 6–7, 2025
LocationMountain View, CA, USA
FocusUUID 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

  1. uuid-creator is the best UUID v7 library for Android — pure Java, no Android-specific dependencies
  2. Room + UUID v7 — use String primary keys, ORDER BY id replaces ORDER BY created_at
  3. WorkManager — java.util.UUID.fromString() accepts UUID v7 strings directly
  4. Avoid UUID v7 on the main thread — use Dispatchers.Default for batch generation
  5. UUID v7 strings in SharedPreferences — save as string, parse on read; no serialization overhead

Further reading

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.